Software / code / prosody
Annotate
spec/util_dataforms_spec.lua @ 13014:06453c564141
util.startup: Add prosody.started promise to easily execute code after startup
To avoid a race where server-started fires before the promise function body is
run (on next tick), I moved server-started to fire on the next tick, which
seems sensible anyway.
Errors are logged, I'm not sure if we ought to be doing something more here.
I'm sure we'll find out.
| author | Matthew Wild <mwild1@gmail.com> |
|---|---|
| date | Sat, 01 Apr 2023 11:56:38 +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 |
