Software / code / prosody
Annotate
spec/util_dataforms_spec.lua @ 12393:6966026262f4 0.12
mod_admin_socket: Comment on LuaSocket UNIX compat code
Ref #1717
| author | Kim Alvefur <zash@zash.se> |
|---|---|
| date | Wed, 16 Mar 2022 19:32:17 +0100 |
| parent | 12387:05c250fa335a |
| child | 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); | |
| 133 assert.equal("FORM_TYPE", xform:find("field@var")); | |
| 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 |
