Software /
code /
prosody
Annotate
spec/util_dataforms_spec.lua @ 13031:1023c3faffac
util.human.io: Fix pattern to support fractional proportions
author | Matthew Wild <mwild1@gmail.com> |
---|---|
date | Thu, 06 Apr 2023 15:03:45 +0100 |
parent | 12636:e8934ce6ea0f |
rev | line source |
---|---|
8862 | 1 local dataforms = require "util.dataforms"; |
2 local st = require "util.stanza"; | |
3 local jid = require "util.jid"; | |
4 local iter = require "util.iterators"; | |
5 | |
6 describe("util.dataforms", function () | |
7 local some_form, xform; | |
8 setup(function () | |
9 some_form = dataforms.new({ | |
10 title = "form-title", | |
11 instructions = "form-instructions", | |
12 { | |
13 type = "hidden", | |
14 name = "FORM_TYPE", | |
15 value = "xmpp:prosody.im/spec/util.dataforms#1", | |
16 }; | |
17 { | |
9046
7cdc718312c8
util.dataforms: Include a fixed field in test
Kim Alvefur <zash@zash.se>
parents:
8864
diff
changeset
|
18 type = "fixed"; |
7cdc718312c8
util.dataforms: Include a fixed field in test
Kim Alvefur <zash@zash.se>
parents:
8864
diff
changeset
|
19 value = "Fixed field"; |
7cdc718312c8
util.dataforms: Include a fixed field in test
Kim Alvefur <zash@zash.se>
parents:
8864
diff
changeset
|
20 }, |
7cdc718312c8
util.dataforms: Include a fixed field in test
Kim Alvefur <zash@zash.se>
parents:
8864
diff
changeset
|
21 { |
8862 | 22 type = "boolean", |
23 label = "boolean-label", | |
24 name = "boolean-field", | |
25 value = true, | |
26 }, | |
27 { | |
28 type = "fixed", | |
29 label = "fixed-label", | |
30 name = "fixed-field", | |
31 value = "fixed-value", | |
32 }, | |
33 { | |
34 type = "hidden", | |
35 label = "hidden-label", | |
36 name = "hidden-field", | |
37 value = "hidden-value", | |
38 }, | |
39 { | |
40 type = "jid-multi", | |
41 label = "jid-multi-label", | |
42 name = "jid-multi-field", | |
43 value = { | |
44 "jid@multi/value#1", | |
45 "jid@multi/value#2", | |
46 }, | |
47 }, | |
48 { | |
49 type = "jid-single", | |
50 label = "jid-single-label", | |
51 name = "jid-single-field", | |
52 value = "jid@single/value", | |
53 }, | |
54 { | |
55 type = "list-multi", | |
56 label = "list-multi-label", | |
57 name = "list-multi-field", | |
58 value = { | |
59 "list-multi-option-value#1", | |
60 "list-multi-option-value#3", | |
61 }, | |
62 options = { | |
63 { | |
64 label = "list-multi-option-label#1", | |
65 value = "list-multi-option-value#1", | |
66 default = true, | |
67 }, | |
68 { | |
69 label = "list-multi-option-label#2", | |
70 value = "list-multi-option-value#2", | |
71 default = false, | |
72 }, | |
73 { | |
74 label = "list-multi-option-label#3", | |
75 value = "list-multi-option-value#3", | |
76 default = true, | |
77 }, | |
78 } | |
79 }, | |
80 { | |
81 type = "list-single", | |
82 label = "list-single-label", | |
83 name = "list-single-field", | |
84 value = "list-single-value", | |
85 options = { | |
86 "list-single-value", | |
87 "list-single-value#2", | |
88 "list-single-value#3", | |
89 } | |
90 }, | |
91 { | |
92 type = "text-multi", | |
93 label = "text-multi-label", | |
94 name = "text-multi-field", | |
95 value = "text\nmulti\nvalue", | |
96 }, | |
97 { | |
98 type = "text-private", | |
99 label = "text-private-label", | |
100 name = "text-private-field", | |
101 value = "text-private-value", | |
102 }, | |
103 { | |
104 type = "text-single", | |
105 label = "text-single-label", | |
106 name = "text-single-field", | |
107 value = "text-single-value", | |
108 }, | |
11026
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
109 { |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
110 -- XEP-0221 |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
111 -- TODO Validate the XML produced by this. |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
112 type = "text-single", |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
113 label = "text-single-with-media-label", |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
114 name = "text-single-with-media-field", |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
115 media = { |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
116 height = 24, |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
117 width = 32, |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
118 { |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
119 type = "image/png", |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
120 uri = "data:", |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
121 }, |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
122 }, |
a086825ed73a
util.dataforms: Convert media element sizes to avoid error on Lua 5.3
Kim Alvefur <zash@zash.se>
parents:
10512
diff
changeset
|
123 }, |
8862 | 124 }); |
125 xform = some_form:form(); | |
126 end); | |
127 | |
10512
3089086d31fa
util.dataforms: Improve descriptions in tests
Kim Alvefur <zash@zash.se>
parents:
9243
diff
changeset
|
128 it("XML serialization looks like it should", function () |
8862 | 129 assert.truthy(xform); |
130 assert.truthy(st.is_stanza(xform)); | |
131 assert.equal("x", xform.name); | |
132 assert.equal("jabber:x:data", xform.attr.xmlns); | |
12636
e8934ce6ea0f
util.stanza: Add method for extracting a single attribute value
Kim Alvefur <zash@zash.se>
parents:
12387
diff
changeset
|
133 assert.equal("FORM_TYPE", xform:get_child_attr("field", nil, "var")); |
8862 | 134 assert.equal("xmpp:prosody.im/spec/util.dataforms#1", xform:find("field/value#")); |
135 local allowed_direct_children = { | |
136 title = true, | |
137 instructions = true, | |
138 field = true, | |
139 } | |
140 for tag in xform:childtags() do | |
141 assert.truthy(allowed_direct_children[tag.name], "unknown direct child"); | |
142 end | |
143 end); | |
144 | |
145 it("produced boolean field correctly", function () | |
146 local f; | |
147 for field in xform:childtags("field") do | |
148 if field.attr.var == "boolean-field" then | |
149 f = field; | |
150 break; | |
151 end | |
152 end | |
153 | |
154 assert.truthy(st.is_stanza(f)); | |
155 assert.equal("boolean-field", f.attr.var); | |
156 assert.equal("boolean", f.attr.type); | |
157 assert.equal("boolean-label", f.attr.label); | |
158 assert.equal(1, iter.count(f:childtags("value"))); | |
159 local val = f:get_child_text("value"); | |
160 assert.truthy(val == "true" or val == "1"); | |
161 end); | |
162 | |
163 it("produced fixed field correctly", function () | |
164 local f; | |
165 for field in xform:childtags("field") do | |
166 if field.attr.var == "fixed-field" then | |
167 f = field; | |
168 break; | |
169 end | |
170 end | |
171 | |
172 assert.truthy(st.is_stanza(f)); | |
173 assert.equal("fixed-field", f.attr.var); | |
174 assert.equal("fixed", f.attr.type); | |
175 assert.equal("fixed-label", f.attr.label); | |
176 assert.equal(1, iter.count(f:childtags("value"))); | |
177 assert.equal("fixed-value", f:get_child_text("value")); | |
178 end); | |
179 | |
180 it("produced hidden field correctly", function () | |
181 local f; | |
182 for field in xform:childtags("field") do | |
183 if field.attr.var == "hidden-field" then | |
184 f = field; | |
185 break; | |
186 end | |
187 end | |
188 | |
189 assert.truthy(st.is_stanza(f)); | |
190 assert.equal("hidden-field", f.attr.var); | |
191 assert.equal("hidden", f.attr.type); | |
192 assert.equal("hidden-label", f.attr.label); | |
193 assert.equal(1, iter.count(f:childtags("value"))); | |
194 assert.equal("hidden-value", f:get_child_text("value")); | |
195 end); | |
196 | |
197 it("produced jid-multi field correctly", function () | |
198 local f; | |
199 for field in xform:childtags("field") do | |
200 if field.attr.var == "jid-multi-field" then | |
201 f = field; | |
202 break; | |
203 end | |
204 end | |
205 | |
206 assert.truthy(st.is_stanza(f)); | |
207 assert.equal("jid-multi-field", f.attr.var); | |
208 assert.equal("jid-multi", f.attr.type); | |
209 assert.equal("jid-multi-label", f.attr.label); | |
210 assert.equal(2, iter.count(f:childtags("value"))); | |
211 | |
212 local i = 0; | |
213 for value in f:childtags("value") do | |
214 i = i + 1; | |
215 assert.equal(("jid@multi/value#%d"):format(i), value:get_text()); | |
216 end | |
217 end); | |
218 | |
219 it("produced jid-single field correctly", function () | |
220 local f; | |
221 for field in xform:childtags("field") do | |
222 if field.attr.var == "jid-single-field" then | |
223 f = field; | |
224 break; | |
225 end | |
226 end | |
227 | |
228 assert.truthy(st.is_stanza(f)); | |
229 assert.equal("jid-single-field", f.attr.var); | |
230 assert.equal("jid-single", f.attr.type); | |
231 assert.equal("jid-single-label", f.attr.label); | |
232 assert.equal(1, iter.count(f:childtags("value"))); | |
233 assert.equal("jid@single/value", f:get_child_text("value")); | |
234 assert.truthy(jid.prep(f:get_child_text("value"))); | |
235 end); | |
236 | |
237 it("produced list-multi field correctly", function () | |
238 local f; | |
239 for field in xform:childtags("field") do | |
240 if field.attr.var == "list-multi-field" then | |
241 f = field; | |
242 break; | |
243 end | |
244 end | |
245 | |
246 assert.truthy(st.is_stanza(f)); | |
247 assert.equal("list-multi-field", f.attr.var); | |
248 assert.equal("list-multi", f.attr.type); | |
249 assert.equal("list-multi-label", f.attr.label); | |
250 assert.equal(2, iter.count(f:childtags("value"))); | |
251 assert.equal("list-multi-option-value#1", f:get_child_text("value")); | |
252 assert.equal(3, iter.count(f:childtags("option"))); | |
253 end); | |
254 | |
255 it("produced list-single field correctly", function () | |
256 local f; | |
257 for field in xform:childtags("field") do | |
258 if field.attr.var == "list-single-field" then | |
259 f = field; | |
260 break; | |
261 end | |
262 end | |
263 | |
264 assert.truthy(st.is_stanza(f)); | |
265 assert.equal("list-single-field", f.attr.var); | |
266 assert.equal("list-single", f.attr.type); | |
267 assert.equal("list-single-label", f.attr.label); | |
268 assert.equal(1, iter.count(f:childtags("value"))); | |
269 assert.equal("list-single-value", f:get_child_text("value")); | |
270 assert.equal(3, iter.count(f:childtags("option"))); | |
271 end); | |
272 | |
273 it("produced text-multi field correctly", function () | |
274 local f; | |
275 for field in xform:childtags("field") do | |
276 if field.attr.var == "text-multi-field" then | |
277 f = field; | |
278 break; | |
279 end | |
280 end | |
281 | |
282 assert.truthy(st.is_stanza(f)); | |
283 assert.equal("text-multi-field", f.attr.var); | |
284 assert.equal("text-multi", f.attr.type); | |
285 assert.equal("text-multi-label", f.attr.label); | |
286 assert.equal(3, iter.count(f:childtags("value"))); | |
287 end); | |
288 | |
289 it("produced text-private field correctly", function () | |
290 local f; | |
291 for field in xform:childtags("field") do | |
292 if field.attr.var == "text-private-field" then | |
293 f = field; | |
294 break; | |
295 end | |
296 end | |
297 | |
298 assert.truthy(st.is_stanza(f)); | |
299 assert.equal("text-private-field", f.attr.var); | |
300 assert.equal("text-private", f.attr.type); | |
301 assert.equal("text-private-label", f.attr.label); | |
302 assert.equal(1, iter.count(f:childtags("value"))); | |
303 assert.equal("text-private-value", f:get_child_text("value")); | |
304 end); | |
305 | |
306 it("produced text-single field correctly", function () | |
307 local f; | |
308 for field in xform:childtags("field") do | |
309 if field.attr.var == "text-single-field" then | |
310 f = field; | |
311 break; | |
312 end | |
313 end | |
314 | |
315 assert.truthy(st.is_stanza(f)); | |
316 assert.equal("text-single-field", f.attr.var); | |
317 assert.equal("text-single", f.attr.type); | |
318 assert.equal("text-single-label", f.attr.label); | |
319 assert.equal(1, iter.count(f:childtags("value"))); | |
320 assert.equal("text-single-value", f:get_child_text("value")); | |
321 end); | |
322 | |
8864
cf2f66b233d1
util.dataforms: Add a simple function for identifying form types
Kim Alvefur <zash@zash.se>
parents:
8862
diff
changeset
|
323 describe("get_type()", function () |
cf2f66b233d1
util.dataforms: Add a simple function for identifying form types
Kim Alvefur <zash@zash.se>
parents:
8862
diff
changeset
|
324 it("identifes dataforms", function () |
cf2f66b233d1
util.dataforms: Add a simple function for identifying form types
Kim Alvefur <zash@zash.se>
parents:
8862
diff
changeset
|
325 assert.equal(nil, dataforms.get_type(nil)); |
cf2f66b233d1
util.dataforms: Add a simple function for identifying form types
Kim Alvefur <zash@zash.se>
parents:
8862
diff
changeset
|
326 assert.equal(nil, dataforms.get_type("")); |
cf2f66b233d1
util.dataforms: Add a simple function for identifying form types
Kim Alvefur <zash@zash.se>
parents:
8862
diff
changeset
|
327 assert.equal(nil, dataforms.get_type({})); |
cf2f66b233d1
util.dataforms: Add a simple function for identifying form types
Kim Alvefur <zash@zash.se>
parents:
8862
diff
changeset
|
328 assert.equal(nil, dataforms.get_type(st.stanza("no-a-form"))); |
cf2f66b233d1
util.dataforms: Add a simple function for identifying form types
Kim Alvefur <zash@zash.se>
parents:
8862
diff
changeset
|
329 assert.equal("xmpp:prosody.im/spec/util.dataforms#1", dataforms.get_type(xform)); |
cf2f66b233d1
util.dataforms: Add a simple function for identifying form types
Kim Alvefur <zash@zash.se>
parents:
8862
diff
changeset
|
330 end); |
cf2f66b233d1
util.dataforms: Add a simple function for identifying form types
Kim Alvefur <zash@zash.se>
parents:
8862
diff
changeset
|
331 end); |
9046
7cdc718312c8
util.dataforms: Include a fixed field in test
Kim Alvefur <zash@zash.se>
parents:
8864
diff
changeset
|
332 |
7cdc718312c8
util.dataforms: Include a fixed field in test
Kim Alvefur <zash@zash.se>
parents:
8864
diff
changeset
|
333 describe(":data", function () |
10512
3089086d31fa
util.dataforms: Improve descriptions in tests
Kim Alvefur <zash@zash.se>
parents:
9243
diff
changeset
|
334 it("returns something", function () |
9046
7cdc718312c8
util.dataforms: Include a fixed field in test
Kim Alvefur <zash@zash.se>
parents:
8864
diff
changeset
|
335 assert.truthy(some_form:data(xform)); |
7cdc718312c8
util.dataforms: Include a fixed field in test
Kim Alvefur <zash@zash.se>
parents:
8864
diff
changeset
|
336 end); |
7cdc718312c8
util.dataforms: Include a fixed field in test
Kim Alvefur <zash@zash.se>
parents:
8864
diff
changeset
|
337 end); |
9083
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
338 |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
339 describe("issue1177", function () |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
340 local form_with_stuff; |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
341 setup(function () |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
342 form_with_stuff = dataforms.new({ |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
343 { |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
344 type = "list-single"; |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
345 name = "abtest"; |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
346 label = "A or B?"; |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
347 options = { |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
348 { label = "A", value = "a", default = true }, |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
349 { label = "B", value = "b" }, |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
350 }; |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
351 }, |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
352 }); |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
353 end); |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
354 |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
355 it("includes options when value is included", function () |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
356 local f = form_with_stuff:form({ abtest = "a" }); |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
357 assert.truthy(f:find("field/option")); |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
358 end); |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
359 |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
360 it("includes options when value is excluded", function () |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
361 local f = form_with_stuff:form({}); |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
362 assert.truthy(f:find("field/option")); |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
363 end); |
5d3639e415bd
util.dataforms: Add failing test for #1177
Kim Alvefur <zash@zash.se>
parents:
9046
diff
changeset
|
364 end); |
9121
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
365 |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
366 describe("using current values in place of missing fields", function () |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
367 it("gets back the previous values when given an empty form", function () |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
368 local current = { |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
369 ["list-multi-field"] = { |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
370 "list-multi-option-value#2"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
371 }; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
372 ["list-single-field"] = "list-single-value#2"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
373 ["hidden-field"] = "hidden-value"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
374 ["boolean-field"] = false; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
375 ["text-multi-field"] = "words\ngo\nhere"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
376 ["jid-single-field"] = "alice@example.com"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
377 ["text-private-field"] = "hunter2"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
378 ["text-single-field"] = "text-single-value"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
379 ["jid-multi-field"] = { |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
380 "bob@example.net"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
381 }; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
382 }; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
383 local expect = { |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
384 -- FORM_TYPE = "xmpp:prosody.im/spec/util.dataforms#1"; -- does this need to be included? |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
385 ["list-multi-field"] = { |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
386 "list-multi-option-value#2"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
387 }; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
388 ["list-single-field"] = "list-single-value#2"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
389 ["hidden-field"] = "hidden-value"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
390 ["boolean-field"] = false; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
391 ["text-multi-field"] = "words\ngo\nhere"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
392 ["jid-single-field"] = "alice@example.com"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
393 ["text-private-field"] = "hunter2"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
394 ["text-single-field"] = "text-single-value"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
395 ["jid-multi-field"] = { |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
396 "bob@example.net"; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
397 }; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
398 }; |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
399 local data, err = some_form:data(st.stanza("x", {xmlns="jabber:x:data"}), current); |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
400 assert.is.table(data, err); |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
401 assert.same(expect, data, "got back the same data"); |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
402 end); |
e5eb36ee07a2
util.dataforms: Allow passing the current values to be used in stead of omitted fields
Kim Alvefur <zash@zash.se>
parents:
9083
diff
changeset
|
403 end); |
9242
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
404 |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
405 describe("field 'var' property", function () |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
406 it("works as expected", function () |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
407 local f = dataforms.new { |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
408 { |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
409 var = "someprefix#the-field", |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
410 name = "the_field", |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
411 type = "text-single", |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
412 } |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
413 }; |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
414 local x = f:form({the_field = "hello"}); |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
415 assert.equal("someprefix#the-field", x:find"field@var"); |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
416 assert.equal("hello", x:find"field/value#"); |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
417 end); |
68694c1bd960
util.dataforms: Allow field names to be different from the 'var' attribute
Kim Alvefur <zash@zash.se>
parents:
9121
diff
changeset
|
418 end); |
9243
a4c52e304e6f
util.dataforms: Add support for XEP-0122: Data Forms Validation
Kim Alvefur <zash@zash.se>
parents:
9242
diff
changeset
|
419 |
11877
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
420 describe("number handling", function() |
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
421 it("handles numbers as booleans", function() |
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
422 local f = dataforms.new { { name = "boolean"; type = "boolean" } }; |
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
423 local x = f:form({ boolean = 0 }); |
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
424 assert.equal("0", x:find "field/value#"); |
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
425 x = f:form({ boolean = 1 }); |
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
426 assert.equal("1", x:find "field/value#"); |
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
427 end); |
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
428 end) |
593b141ba01c
util.dataforms: Coerce number values for boolean fields
Kim Alvefur <zash@zash.se>
parents:
11874
diff
changeset
|
429 |
10512
3089086d31fa
util.dataforms: Improve descriptions in tests
Kim Alvefur <zash@zash.se>
parents:
9243
diff
changeset
|
430 describe("datatype validation", function () |
11879
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
431 describe("integer", function () |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
432 |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
433 local f = dataforms.new { |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
434 { |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
435 name = "number", |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
436 type = "text-single", |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
437 datatype = "xs:integer", |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
438 range_min = -10, |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
439 range_max = 10, |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
440 }, |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
441 }; |
9243
a4c52e304e6f
util.dataforms: Add support for XEP-0122: Data Forms Validation
Kim Alvefur <zash@zash.se>
parents:
9242
diff
changeset
|
442 |
11879
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
443 it("roundtrip works", function () |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
444 local d = f:data(f:form({number = 1})); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
445 assert.equal(1, d.number); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
446 end); |
9243
a4c52e304e6f
util.dataforms: Add support for XEP-0122: Data Forms Validation
Kim Alvefur <zash@zash.se>
parents:
9242
diff
changeset
|
447 |
11879
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
448 it("error handling works", function () |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
449 local d,e = f:data(f:form({number = "nan"})); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
450 assert.not_equal(1, d.number); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
451 assert.table(e); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
452 assert.string(e.number); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
453 end); |
11070
f7f30a3464fe
util.dataforms: Add support for validating (integer) ranges
Kim Alvefur <zash@zash.se>
parents:
11027
diff
changeset
|
454 |
12387
05c250fa335a
Spelling: Fix various spelling mistakes (thanks timeless)
Kim Alvefur <zash@zash.se>
parents:
11880
diff
changeset
|
455 it("bounds-checking work works", function () |
11879
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
456 local d,e = f:data(f:form({number = 100})); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
457 assert.not_equal(100, d.number); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
458 assert.table(e); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
459 assert.string(e.number); |
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
460 end); |
11880
d30c81b875f2
util.dataforms: Ensure larger integers are serialized as such
Kim Alvefur <zash@zash.se>
parents:
11879
diff
changeset
|
461 |
12387
05c250fa335a
Spelling: Fix various spelling mistakes (thanks timeless)
Kim Alvefur <zash@zash.se>
parents:
11880
diff
changeset
|
462 it("serializes larger ints okay", function () |
11880
d30c81b875f2
util.dataforms: Ensure larger integers are serialized as such
Kim Alvefur <zash@zash.se>
parents:
11879
diff
changeset
|
463 local x = f:form{number=1125899906842624} |
d30c81b875f2
util.dataforms: Ensure larger integers are serialized as such
Kim Alvefur <zash@zash.se>
parents:
11879
diff
changeset
|
464 assert.equal("1125899906842624", x:find("field/value#")) |
d30c81b875f2
util.dataforms: Ensure larger integers are serialized as such
Kim Alvefur <zash@zash.se>
parents:
11879
diff
changeset
|
465 end); |
d30c81b875f2
util.dataforms: Ensure larger integers are serialized as such
Kim Alvefur <zash@zash.se>
parents:
11879
diff
changeset
|
466 |
11879
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
467 end) |
11874
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
468 |
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
469 describe("datetime", function () |
11879
b8b889ba8d27
util.dataforms: Scope integer handling tests
Kim Alvefur <zash@zash.se>
parents:
11878
diff
changeset
|
470 local f = dataforms.new { { name = "when"; type = "text-single"; datatype = "xs:dateTime" } } |
11874
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
471 |
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
472 it("works", function () |
11878
bf6706057283
util.dataforms: Turn number values into timestamps for datetime fields
Kim Alvefur <zash@zash.se>
parents:
11877
diff
changeset
|
473 local x = f:form({ when = 1219439340 }); |
11874
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
474 assert.equal("2008-08-22T21:09:00Z", x:find("field/value#")) |
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
475 local d, e = f:data(x); |
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
476 assert.is_nil(e); |
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
477 assert.same({ when = 1219439340 }, d); |
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
478 end); |
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
479 |
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
480 end) |
84f4c6957d62
util.dataforms: Add support for datetime field types via XEP-0122
Kim Alvefur <zash@zash.se>
parents:
11070
diff
changeset
|
481 |
9243
a4c52e304e6f
util.dataforms: Add support for XEP-0122: Data Forms Validation
Kim Alvefur <zash@zash.se>
parents:
9242
diff
changeset
|
482 end); |
11027
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
483 describe("media element", function () |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
484 it("produced media element correctly", function () |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
485 local f; |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
486 for field in xform:childtags("field") do |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
487 if field.attr.var == "text-single-with-media-field" then |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
488 f = field; |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
489 break; |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
490 end |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
491 end |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
492 |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
493 assert.truthy(st.is_stanza(f)); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
494 assert.equal("text-single-with-media-field", f.attr.var); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
495 assert.equal("text-single", f.attr.type); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
496 assert.equal("text-single-with-media-label", f.attr.label); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
497 assert.equal(0, iter.count(f:childtags("value"))); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
498 |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
499 local m = f:get_child("media", "urn:xmpp:media-element"); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
500 assert.truthy(st.is_stanza(m)); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
501 assert.equal("24", m.attr.height); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
502 assert.equal("32", m.attr.width); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
503 assert.equal(1, iter.count(m:childtags("uri"))); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
504 |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
505 local u = m:get_child("uri"); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
506 assert.truthy(st.is_stanza(u)); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
507 assert.equal("image/png", u.attr.type); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
508 assert.equal("data:", u:get_text()); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
509 end); |
8ed6c5bdbb21
util.dataforms: Add more XEP-0211 media element test coverage
Kim Alvefur <zash@zash.se>
parents:
11026
diff
changeset
|
510 end); |
8862 | 511 end); |
512 |