spec/util_dataforms_spec.lua

   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                         {
  18                                 type = "fixed";
  19                                 value = "Fixed field";
  20                         },
  21                         {
  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                         },
 109                 });
 110                 xform = some_form:form();
 111         end);
 112
 113         it("works", function ()
 114                 assert.truthy(xform);
 115                 assert.truthy(st.is_stanza(xform));
 116                 assert.equal("x", xform.name);
 117                 assert.equal("jabber:x:data", xform.attr.xmlns);
 118                 assert.equal("FORM_TYPE", xform:find("field@var"));
 119                 assert.equal("xmpp:prosody.im/spec/util.dataforms#1", xform:find("field/value#"));
 120                 local allowed_direct_children = {
 121                         title = true,
 122                         instructions = true,
 123                         field = true,
 124                 }
 125                 for tag in xform:childtags() do
 126                         assert.truthy(allowed_direct_children[tag.name], "unknown direct child");
 127                 end
 128         end);
 129
 130         it("produced boolean field correctly", function ()
 131                 local f;
 132                 for field in xform:childtags("field") do
 133                         if field.attr.var == "boolean-field" then
 134                                 f = field;
 135                                 break;
 136                         end
 137                 end
 138
 139                 assert.truthy(st.is_stanza(f));
 140                 assert.equal("boolean-field", f.attr.var);
 141                 assert.equal("boolean", f.attr.type);
 142                 assert.equal("boolean-label", f.attr.label);
 143                 assert.equal(1, iter.count(f:childtags("value")));
 144                 local val = f:get_child_text("value");
 145                 assert.truthy(val == "true" or val == "1");
 146         end);
 147
 148         it("produced fixed field correctly", function ()
 149                 local f;
 150                 for field in xform:childtags("field") do
 151                         if field.attr.var == "fixed-field" then
 152                                 f = field;
 153                                 break;
 154                         end
 155                 end
 156
 157                 assert.truthy(st.is_stanza(f));
 158                 assert.equal("fixed-field", f.attr.var);
 159                 assert.equal("fixed", f.attr.type);
 160                 assert.equal("fixed-label", f.attr.label);
 161                 assert.equal(1, iter.count(f:childtags("value")));
 162                 assert.equal("fixed-value", f:get_child_text("value"));
 163         end);
 164
 165         it("produced hidden field correctly", function ()
 166                 local f;
 167                 for field in xform:childtags("field") do
 168                         if field.attr.var == "hidden-field" then
 169                                 f = field;
 170                                 break;
 171                         end
 172                 end
 173
 174                 assert.truthy(st.is_stanza(f));
 175                 assert.equal("hidden-field", f.attr.var);
 176                 assert.equal("hidden", f.attr.type);
 177                 assert.equal("hidden-label", f.attr.label);
 178                 assert.equal(1, iter.count(f:childtags("value")));
 179                 assert.equal("hidden-value", f:get_child_text("value"));
 180         end);
 181
 182         it("produced jid-multi field correctly", function ()
 183                 local f;
 184                 for field in xform:childtags("field") do
 185                         if field.attr.var == "jid-multi-field" then
 186                                 f = field;
 187                                 break;
 188                         end
 189                 end
 190
 191                 assert.truthy(st.is_stanza(f));
 192                 assert.equal("jid-multi-field", f.attr.var);
 193                 assert.equal("jid-multi", f.attr.type);
 194                 assert.equal("jid-multi-label", f.attr.label);
 195                 assert.equal(2, iter.count(f:childtags("value")));
 196
 197                 local i = 0;
 198                 for value in f:childtags("value") do
 199                         i = i + 1;
 200                         assert.equal(("jid@multi/value#%d"):format(i), value:get_text());
 201                 end
 202         end);
 203
 204         it("produced jid-single field correctly", function ()
 205                 local f;
 206                 for field in xform:childtags("field") do
 207                         if field.attr.var == "jid-single-field" then
 208                                 f = field;
 209                                 break;
 210                         end
 211                 end
 212
 213                 assert.truthy(st.is_stanza(f));
 214                 assert.equal("jid-single-field", f.attr.var);
 215                 assert.equal("jid-single", f.attr.type);
 216                 assert.equal("jid-single-label", f.attr.label);
 217                 assert.equal(1, iter.count(f:childtags("value")));
 218                 assert.equal("jid@single/value", f:get_child_text("value"));
 219                 assert.truthy(jid.prep(f:get_child_text("value")));
 220         end);
 221
 222         it("produced list-multi field correctly", function ()
 223                 local f;
 224                 for field in xform:childtags("field") do
 225                         if field.attr.var == "list-multi-field" then
 226                                 f = field;
 227                                 break;
 228                         end
 229                 end
 230
 231                 assert.truthy(st.is_stanza(f));
 232                 assert.equal("list-multi-field", f.attr.var);
 233                 assert.equal("list-multi", f.attr.type);
 234                 assert.equal("list-multi-label", f.attr.label);
 235                 assert.equal(2, iter.count(f:childtags("value")));
 236                 assert.equal("list-multi-option-value#1", f:get_child_text("value"));
 237                 assert.equal(3, iter.count(f:childtags("option")));
 238         end);
 239
 240         it("produced list-single field correctly", function ()
 241                 local f;
 242                 for field in xform:childtags("field") do
 243                         if field.attr.var == "list-single-field" then
 244                                 f = field;
 245                                 break;
 246                         end
 247                 end
 248
 249                 assert.truthy(st.is_stanza(f));
 250                 assert.equal("list-single-field", f.attr.var);
 251                 assert.equal("list-single", f.attr.type);
 252                 assert.equal("list-single-label", f.attr.label);
 253                 assert.equal(1, iter.count(f:childtags("value")));
 254                 assert.equal("list-single-value", f:get_child_text("value"));
 255                 assert.equal(3, iter.count(f:childtags("option")));
 256         end);
 257
 258         it("produced text-multi field correctly", function ()
 259                 local f;
 260                 for field in xform:childtags("field") do
 261                         if field.attr.var == "text-multi-field" then
 262                                 f = field;
 263                                 break;
 264                         end
 265                 end
 266
 267                 assert.truthy(st.is_stanza(f));
 268                 assert.equal("text-multi-field", f.attr.var);
 269                 assert.equal("text-multi", f.attr.type);
 270                 assert.equal("text-multi-label", f.attr.label);
 271                 assert.equal(3, iter.count(f:childtags("value")));
 272         end);
 273
 274         it("produced text-private field correctly", function ()
 275                 local f;
 276                 for field in xform:childtags("field") do
 277                         if field.attr.var == "text-private-field" then
 278                                 f = field;
 279                                 break;
 280                         end
 281                 end
 282
 283                 assert.truthy(st.is_stanza(f));
 284                 assert.equal("text-private-field", f.attr.var);
 285                 assert.equal("text-private", f.attr.type);
 286                 assert.equal("text-private-label", f.attr.label);
 287                 assert.equal(1, iter.count(f:childtags("value")));
 288                 assert.equal("text-private-value", f:get_child_text("value"));
 289         end);
 290
 291         it("produced text-single field correctly", function ()
 292                 local f;
 293                 for field in xform:childtags("field") do
 294                         if field.attr.var == "text-single-field" then
 295                                 f = field;
 296                                 break;
 297                         end
 298                 end
 299
 300                 assert.truthy(st.is_stanza(f));
 301                 assert.equal("text-single-field", f.attr.var);
 302                 assert.equal("text-single", f.attr.type);
 303                 assert.equal("text-single-label", f.attr.label);
 304                 assert.equal(1, iter.count(f:childtags("value")));
 305                 assert.equal("text-single-value", f:get_child_text("value"));
 306         end);
 307
 308         describe("get_type()", function ()
 309                 it("identifes dataforms", function ()
 310                         assert.equal(nil, dataforms.get_type(nil));
 311                         assert.equal(nil, dataforms.get_type(""));
 312                         assert.equal(nil, dataforms.get_type({}));
 313                         assert.equal(nil, dataforms.get_type(st.stanza("no-a-form")));
 314                         assert.equal("xmpp:prosody.im/spec/util.dataforms#1", dataforms.get_type(xform));
 315                 end);
 316         end);
 317
 318         describe(":data", function ()
 319                 it("works", function ()
 320                         assert.truthy(some_form:data(xform));
 321                 end);
 322         end);
 323
 324         describe("issue1177", function ()
 325                 local form_with_stuff;
 326                 setup(function ()
 327                         form_with_stuff = dataforms.new({
 328                                 {
 329                                         type = "list-single";
 330                                         name = "abtest";
 331                                         label = "A or B?";
 332                                         options = {
 333                                                 { label = "A", value = "a", default = true },
 334                                                 { label = "B", value = "b" },
 335                                         };
 336                                 },
 337                         });
 338                 end);
 339
 340                 it("includes options when value is included", function ()
 341                         local f = form_with_stuff:form({ abtest = "a" });
 342                         assert.truthy(f:find("field/option"));
 343                 end);
 344
 345                 it("includes options when value is excluded", function ()
 346                         local f = form_with_stuff:form({});
 347                         assert.truthy(f:find("field/option"));
 348                 end);
 349         end);
 350
 351         describe("using current values in place of missing fields", function ()
 352                 it("gets back the previous values when given an empty form", function ()
 353                         local current = {
 354                                 ["list-multi-field"] = {
 355                                         "list-multi-option-value#2";
 356                                 };
 357                                 ["list-single-field"] = "list-single-value#2";
 358                                 ["hidden-field"] = "hidden-value";
 359                                 ["boolean-field"] = false;
 360                                 ["text-multi-field"] = "words\ngo\nhere";
 361                                 ["jid-single-field"] = "alice@example.com";
 362                                 ["text-private-field"] = "hunter2";
 363                                 ["text-single-field"] = "text-single-value";
 364                                 ["jid-multi-field"] = {
 365                                         "bob@example.net";
 366                                 };
 367                         };
 368                         local expect = {
 369                                 -- FORM_TYPE = "xmpp:prosody.im/spec/util.dataforms#1"; -- does this need to be included?
 370                                 ["list-multi-field"] = {
 371                                         "list-multi-option-value#2";
 372                                 };
 373                                 ["list-single-field"] = "list-single-value#2";
 374                                 ["hidden-field"] = "hidden-value";
 375                                 ["boolean-field"] = false;
 376                                 ["text-multi-field"] = "words\ngo\nhere";
 377                                 ["jid-single-field"] = "alice@example.com";
 378                                 ["text-private-field"] = "hunter2";
 379                                 ["text-single-field"] = "text-single-value";
 380                                 ["jid-multi-field"] = {
 381                                         "bob@example.net";
 382                                 };
 383                         };
 384                         local data, err = some_form:data(st.stanza("x", {xmlns="jabber:x:data"}), current);
 385                         assert.is.table(data, err);
 386                         assert.same(expect, data, "got back the same data");
 387                 end);
 388         end);
 389
 390         describe("field 'var' property", function ()
 391                 it("works as expected", function ()
 392                         local f = dataforms.new {
 393                                 {
 394                                         var = "someprefix#the-field",
 395                                         name = "the_field",
 396                                         type = "text-single",
 397                                 }
 398                         };
 399                         local x = f:form({the_field = "hello"});
 400                         assert.equal("someprefix#the-field", x:find"field@var");
 401                         assert.equal("hello", x:find"field/value#");
 402                 end);
 403         end);
 404
 405         describe("validation", function ()
 406                 local f = dataforms.new {
 407                         {
 408                                 name = "number",
 409                                 type = "text-single",
 410                                 datatype = "xs:integer",
 411                         },
 412                 };
 413
 414                 it("works", function ()
 415                         local d = f:data(f:form({number = 1}));
 416                         assert.equal(1, d.number);
 417                 end);
 418
 419                 it("works", function ()
 420                         local d,e = f:data(f:form({number = "nan"}));
 421                         assert.not_equal(1, d.number);
 422                         assert.table(e);
 423                         assert.string(e.number);
 424                 end);
 425         end);
 426 end);
 427