Software `/` code `/` prosody

Annotate

spec/util_stanza_spec.lua @ 13055:e732f9dfdfc8

mod_mam: port to use util.human.io.parse_duration Updated by Zash, the original patch by Jonas had put the duration parsing function in util.datetime but MattJ later did the same thing but differently in f4d7fe919969

author	Jonas Schäfer <jonas@wielicki.name>
date	Thu, 28 Apr 2022 20:38:40 +0200
parent	12687:5b69ecaf3427

rev	line source
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	1
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	2 local st = require "util.stanza";
10503 e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	3 local errors = require "util.error";
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	4
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	5 describe("util.stanza", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	6 describe("#preserialize()", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	7 it("should work", function()
9673 e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	8 local stanza = st.stanza("message", { type = "chat" }):text_tag("body", "Hello");
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	9 local stanza2 = st.preserialize(stanza);
9673 e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	10 assert.is_table(stanza2, "Preserialized stanza is a table");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	11 assert.is_nil(getmetatable(stanza2), "Preserialized stanza has no metatable");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	12 assert.is_string(stanza2.name, "Preserialized stanza has a name field");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	13 assert.equal(stanza.name, stanza2.name, "Preserialized stanza has same name as the input stanza");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	14 assert.same(stanza.attr, stanza2.attr, "Preserialized stanza same attr table as input stanza");
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	15 assert.is_nil(stanza2.tags, "Preserialized stanza has no tag list");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	16 assert.is_nil(stanza2.last_add, "Preserialized stanza has no last_add marker");
9673 e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	17 assert.is_table(stanza2[1], "Preserialized child element preserved");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	18 assert.equal("body", stanza2[1].name, "Preserialized child element name preserved");
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	19 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	20 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	21
9673 e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	22 describe("#deserialize()", function()
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	23 it("should work", function()
9673 e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	24 local stanza = { name = "message", attr = { type = "chat" }, { name = "body", attr = { }, "Hello" } };
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	25 local stanza2 = st.deserialize(st.preserialize(stanza));
9673 e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	26
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	27 assert.is_table(stanza2, "Deserialized stanza is a table");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	28 assert.equal(st.stanza_mt, getmetatable(stanza2), "Deserialized stanza has stanza metatable");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	29 assert.is_string(stanza2.name, "Deserialized stanza has a name field");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	30 assert.equal(stanza.name, stanza2.name, "Deserialized stanza has same name as the input table");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	31 assert.same(stanza.attr, stanza2.attr, "Deserialized stanza same attr table as input table");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	32 assert.is_table(stanza2.tags, "Deserialized stanza has tag list");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	33 assert.is_table(stanza2[1], "Deserialized child element preserved");
e7e75b091c96 util.stanza: Improve tests Kim Alvefur <zash@zash.se> parents: 9630 diff changeset	34 assert.equal("body", stanza2[1].name, "Deserialized child element name preserved");
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	35 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	36 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	37
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	38 describe("#stanza()", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	39 it("should work", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	40 local s = st.stanza("foo", { xmlns = "myxmlns", a = "attr-a" });
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	41 assert.are.equal(s.name, "foo");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	42 assert.are.equal(s.attr.xmlns, "myxmlns");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	43 assert.are.equal(s.attr.a, "attr-a");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	44
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	45 local s1 = st.stanza("s1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	46 assert.are.equal(s1.name, "s1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	47 assert.are.equal(s1.attr.xmlns, nil);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	48 assert.are.equal(#s1, 0);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	49 assert.are.equal(#s1.tags, 0);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	50
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	51 s1:tag("child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	52 assert.are.equal(#s1.tags, 1);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	53 assert.are.equal(s1.tags[1].name, "child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	54
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	55 s1:tag("grandchild1"):up();
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	56 assert.are.equal(#s1.tags, 1);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	57 assert.are.equal(s1.tags[1].name, "child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	58 assert.are.equal(#s1.tags[1], 1);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	59 assert.are.equal(s1.tags[1][1].name, "grandchild1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	60
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	61 s1:up():tag("child2");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	62 assert.are.equal(#s1.tags, 2, tostring(s1));
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	63 assert.are.equal(s1.tags[1].name, "child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	64 assert.are.equal(s1.tags[2].name, "child2");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	65 assert.are.equal(#s1.tags[1], 1);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	66 assert.are.equal(s1.tags[1][1].name, "grandchild1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	67
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	68 s1:up():text("Hello world");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	69 assert.are.equal(#s1.tags, 2);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	70 assert.are.equal(#s1, 3);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	71 assert.are.equal(s1.tags[1].name, "child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	72 assert.are.equal(s1.tags[2].name, "child2");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	73 assert.are.equal(#s1.tags[1], 1);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	74 assert.are.equal(s1.tags[1][1].name, "grandchild1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	75 end);
8598 282d544d48f4 util.stanza: Add tests ensuring support for unicode in tag/attr names Matthew Wild <mwild1@gmail.com> parents: 8597 diff changeset	76 it("should work with unicode values", function ()
282d544d48f4 util.stanza: Add tests ensuring support for unicode in tag/attr names Matthew Wild <mwild1@gmail.com> parents: 8597 diff changeset	77 local s = st.stanza("Объект", { xmlns = "myxmlns", ["Объект"] = "&" });
282d544d48f4 util.stanza: Add tests ensuring support for unicode in tag/attr names Matthew Wild <mwild1@gmail.com> parents: 8597 diff changeset	78 assert.are.equal(s.name, "Объект");
282d544d48f4 util.stanza: Add tests ensuring support for unicode in tag/attr names Matthew Wild <mwild1@gmail.com> parents: 8597 diff changeset	79 assert.are.equal(s.attr.xmlns, "myxmlns");
282d544d48f4 util.stanza: Add tests ensuring support for unicode in tag/attr names Matthew Wild <mwild1@gmail.com> parents: 8597 diff changeset	80 assert.are.equal(s.attr["Объект"], "&");
282d544d48f4 util.stanza: Add tests ensuring support for unicode in tag/attr names Matthew Wild <mwild1@gmail.com> parents: 8597 diff changeset	81 end);
8641 c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	82 it("should allow :text() with nil and empty strings", function ()
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	83 local s_control = st.stanza("foo");
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	84 assert.same(st.stanza("foo"):text(), s_control);
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	85 assert.same(st.stanza("foo"):text(nil), s_control);
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	86 assert.same(st.stanza("foo"):text(""), s_control);
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	87 end);
12139 7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	88 it("validates names", function ()
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	89 assert.has_error_match(function ()
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	90 st.stanza("invalid\0name");
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	91 end, "invalid tag name:")
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	92 assert.has_error_match(function ()
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	93 st.stanza("name", { ["foo\1\2\3bar"] = "baz" });
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	94 end, "invalid attribute name: contains control characters")
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	95 assert.has_error_match(function ()
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	96 st.stanza("name", { ["foo"] = "baz\1\2\3\255moo" });
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	97 end, "invalid attribute value: contains control characters")
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	98 end)
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	99 it("validates types", function ()
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	100 assert.has_error_match(function ()
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	101 st.stanza(1);
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	102 end, "invalid tag name: expected string, got number")
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	103 assert.has_error_match(function ()
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	104 st.stanza("name", "string");
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	105 end, "invalid attributes: expected table, got string")
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	106 assert.has_error_match(function ()
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	107 st.stanza("name",{1});
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	108 end, "invalid attribute name: expected string, got number")
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	109 assert.has_error_match(function ()
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	110 st.stanza("name",{foo=1});
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	111 end, "invalid attribute value: expected string, got number")
7d6497294d92 util.stanza: Increase test coverage to cover validation errors Kim Alvefur <zash@zash.se> parents: 11786 diff changeset	112 end)
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	113 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	114
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	115 describe("#message()", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	116 it("should work", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	117 local m = st.message();
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	118 assert.are.equal(m.name, "message");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	119 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	120 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	121
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	122 describe("#iq()", function()
9307 feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	123 it("should create an iq stanza", function()
9732 51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	124 local i = st.iq({ type = "get", id = "foo" });
9307 feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	125 assert.are.equal("iq", i.name);
feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	126 assert.are.equal("foo", i.attr.id);
9732 51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	127 assert.are.equal("get", i.attr.type);
9307 feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	128 end);
feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	129
9732 51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	130 it("should reject stanzas with no attributes", function ()
51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	131 assert.has.error_match(function ()
51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	132 st.iq();
51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	133 end, "attributes");
51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	134 end);
51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	135
51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	136
9307 feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	137 it("should reject stanzas with no id", function ()
feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	138 assert.has.error_match(function ()
9732 51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	139 st.iq({ type = "get" });
9307 feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	140 end, "id attribute");
9732 51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	141 end);
9307 feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	142
9732 51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	143 it("should reject stanzas with no type", function ()
9307 feaef6215bb8 util.stanza: Don't automatically generate ids for iq stanzas Matthew Wild <mwild1@gmail.com> parents: 9302 diff changeset	144 assert.has.error_match(function ()
9732 51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	145 st.iq({ id = "foo" });
51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	146 end, "type attribute");
51583ea2b4fd util.stanza: Require a type attribute for iq stanzas Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	147
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	148 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	149 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	150
9302 57f8e41255fb util.stanza tests: Fix test name (copy/paste error?) Matthew Wild <mwild1@gmail.com> parents: 9217 diff changeset	151 describe("#presence()", function ()
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	152 it("should work", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	153 local p = st.presence();
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	154 assert.are.equal(p.name, "presence");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	155 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	156 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	157
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	158 describe("#reply()", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	159 it("should work for <s>", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	160 -- Test stanza
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	161 local s = st.stanza("s", { to = "touser", from = "fromuser", id = "123" })
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	162 :tag("child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	163 -- Make reply stanza
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	164 local r = st.reply(s);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	165 assert.are.equal(r.name, s.name);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	166 assert.are.equal(r.id, s.id);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	167 assert.are.equal(r.attr.to, s.attr.from);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	168 assert.are.equal(r.attr.from, s.attr.to);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	169 assert.are.equal(#r.tags, 0, "A reply should not include children of the original stanza");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	170 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	171
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	172 it("should work for <iq get>", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	173 -- Test stanza
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	174 local s = st.stanza("iq", { to = "touser", from = "fromuser", id = "123", type = "get" })
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	175 :tag("child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	176 -- Make reply stanza
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	177 local r = st.reply(s);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	178 assert.are.equal(r.name, s.name);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	179 assert.are.equal(r.id, s.id);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	180 assert.are.equal(r.attr.to, s.attr.from);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	181 assert.are.equal(r.attr.from, s.attr.to);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	182 assert.are.equal(r.attr.type, "result");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	183 assert.are.equal(#r.tags, 0, "A reply should not include children of the original stanza");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	184 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	185
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	186 it("should work for <iq set>", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	187 -- Test stanza
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	188 local s = st.stanza("iq", { to = "touser", from = "fromuser", id = "123", type = "set" })
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	189 :tag("child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	190 -- Make reply stanza
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	191 local r = st.reply(s);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	192 assert.are.equal(r.name, s.name);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	193 assert.are.equal(r.id, s.id);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	194 assert.are.equal(r.attr.to, s.attr.from);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	195 assert.are.equal(r.attr.from, s.attr.to);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	196 assert.are.equal(r.attr.type, "result");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	197 assert.are.equal(#r.tags, 0, "A reply should not include children of the original stanza");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	198 end);
10442 22db763c510c util.stanza: Check that argument to reply is a stanza Kim Alvefur <zash@zash.se> parents: 9924 diff changeset	199
22db763c510c util.stanza: Check that argument to reply is a stanza Kim Alvefur <zash@zash.se> parents: 9924 diff changeset	200 it("should reject not-stanzas", function ()
22db763c510c util.stanza: Check that argument to reply is a stanza Kim Alvefur <zash@zash.se> parents: 9924 diff changeset	201 assert.has.error_match(function ()
22db763c510c util.stanza: Check that argument to reply is a stanza Kim Alvefur <zash@zash.se> parents: 9924 diff changeset	202 st.reply(not "a stanza");
22db763c510c util.stanza: Check that argument to reply is a stanza Kim Alvefur <zash@zash.se> parents: 9924 diff changeset	203 end, "expected stanza");
22db763c510c util.stanza: Check that argument to reply is a stanza Kim Alvefur <zash@zash.se> parents: 9924 diff changeset	204 end);
10443 f28718f46196 util.stanza: Remove redundant check for attrs Kim Alvefur <zash@zash.se> parents: 10442 diff changeset	205
f28718f46196 util.stanza: Remove redundant check for attrs Kim Alvefur <zash@zash.se> parents: 10442 diff changeset	206 it("should reject not-stanzas", function ()
f28718f46196 util.stanza: Remove redundant check for attrs Kim Alvefur <zash@zash.se> parents: 10442 diff changeset	207 assert.has.error_match(function ()
f28718f46196 util.stanza: Remove redundant check for attrs Kim Alvefur <zash@zash.se> parents: 10442 diff changeset	208 st.reply({name="x"});
f28718f46196 util.stanza: Remove redundant check for attrs Kim Alvefur <zash@zash.se> parents: 10442 diff changeset	209 end, "expected stanza");
f28718f46196 util.stanza: Remove redundant check for attrs Kim Alvefur <zash@zash.se> parents: 10442 diff changeset	210 end);
f28718f46196 util.stanza: Remove redundant check for attrs Kim Alvefur <zash@zash.se> parents: 10442 diff changeset	211
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	212 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	213
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	214 describe("#error_reply()", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	215 it("should work for <s>", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	216 -- Test stanza
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	217 local s = st.stanza("s", { to = "touser", from = "fromuser", id = "123" })
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	218 :tag("child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	219 -- Make reply stanza
10446 5c2d1b13537c util.stanza: Support the 'by' attribute on errors Kim Alvefur <zash@zash.se> parents: 10445 diff changeset	220 local r = st.error_reply(s, "cancel", "service-unavailable", nil, "host");
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	221 assert.are.equal(r.name, s.name);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	222 assert.are.equal(r.id, s.id);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	223 assert.are.equal(r.attr.to, s.attr.from);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	224 assert.are.equal(r.attr.from, s.attr.to);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	225 assert.are.equal(#r.tags, 1);
8597 6e5fbeaca0f4 util.stanza: Fix tests to call error_reply() correctly, and add tests to ensure it vaguely works Matthew Wild <mwild1@gmail.com> parents: 8236 diff changeset	226 assert.are.equal(r.tags[1].tags[1].name, "service-unavailable");
10446 5c2d1b13537c util.stanza: Support the 'by' attribute on errors Kim Alvefur <zash@zash.se> parents: 10445 diff changeset	227 assert.are.equal(r.tags[1].attr.by, "host");
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	228 end);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	229
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	230 it("should work for <iq get>", function()
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	231 -- Test stanza
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	232 local s = st.stanza("iq", { to = "touser", from = "fromuser", id = "123", type = "get" })
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	233 :tag("child1");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	234 -- Make reply stanza
8597 6e5fbeaca0f4 util.stanza: Fix tests to call error_reply() correctly, and add tests to ensure it vaguely works Matthew Wild <mwild1@gmail.com> parents: 8236 diff changeset	235 local r = st.error_reply(s, "cancel", "service-unavailable");
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	236 assert.are.equal(r.name, s.name);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	237 assert.are.equal(r.id, s.id);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	238 assert.are.equal(r.attr.to, s.attr.from);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	239 assert.are.equal(r.attr.from, s.attr.to);
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	240 assert.are.equal(r.attr.type, "error");
4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	241 assert.are.equal(#r.tags, 1);
8597 6e5fbeaca0f4 util.stanza: Fix tests to call error_reply() correctly, and add tests to ensure it vaguely works Matthew Wild <mwild1@gmail.com> parents: 8236 diff changeset	242 assert.are.equal(r.tags[1].tags[1].name, "service-unavailable");
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	243 end);
10444 4eab1f5a4f3b util.stanza: Check that argument to error_reply is a stanza Kim Alvefur <zash@zash.se> parents: 10443 diff changeset	244
4eab1f5a4f3b util.stanza: Check that argument to error_reply is a stanza Kim Alvefur <zash@zash.se> parents: 10443 diff changeset	245 it("should reject not-stanzas", function ()
4eab1f5a4f3b util.stanza: Check that argument to error_reply is a stanza Kim Alvefur <zash@zash.se> parents: 10443 diff changeset	246 assert.has.error_match(function ()
4eab1f5a4f3b util.stanza: Check that argument to error_reply is a stanza Kim Alvefur <zash@zash.se> parents: 10443 diff changeset	247 st.error_reply(not "a stanza", "modify", "bad-request");
4eab1f5a4f3b util.stanza: Check that argument to error_reply is a stanza Kim Alvefur <zash@zash.se> parents: 10443 diff changeset	248 end, "expected stanza");
4eab1f5a4f3b util.stanza: Check that argument to error_reply is a stanza Kim Alvefur <zash@zash.se> parents: 10443 diff changeset	249 end);
10445 f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	250
f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	251 it("should reject stanzas of type error", function ()
f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	252 assert.has.error_match(function ()
f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	253 st.error_reply(st.message({type="error"}), "cancel", "conflict");
f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	254 end, "got stanza of type error");
f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	255 assert.has.error_match(function ()
f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	256 st.error_reply(st.error_reply(st.message({type="chat"}), "modify", "forbidden"), "cancel", "service-unavailable");
f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	257 end, "got stanza of type error");
f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	258 end);
f53c03ab4357 util.stanza: Check that argument to error_reply is NOT a stanza of type error Kim Alvefur <zash@zash.se> parents: 10444 diff changeset	259
11087 cdd4684992f1 spec.stanza spec: Split up util.error related tests Kim Alvefur <zash@zash.se> parents: 11086 diff changeset	260 describe("util.error integration", function ()
10503 e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	261 it("should accept util.error objects", function ()
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	262 local s = st.message({ to = "touser", from = "fromuser", id = "123", type = "chat" }, "Hello");
11085 5705d151ea11 util.stanza: Get 'by' from context instead Kim Alvefur <zash@zash.se> parents: 11084 diff changeset	263 local e = errors.new({ type = "modify", condition = "not-acceptable", text = "Bork bork bork" }, { by = "this.test" });
10503 e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	264 local r = st.error_reply(s, e);
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	265
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	266 assert.are.equal(r.name, s.name);
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	267 assert.are.equal(r.id, s.id);
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	268 assert.are.equal(r.attr.to, s.attr.from);
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	269 assert.are.equal(r.attr.from, s.attr.to);
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	270 assert.are.equal(r.attr.type, "error");
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	271 assert.are.equal(r.tags[1].name, "error");
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	272 assert.are.equal(r.tags[1].attr.type, e.type);
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	273 assert.are.equal(r.tags[1].tags[1].name, e.condition);
e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	274 assert.are.equal(r.tags[1].tags[2]:get_text(), e.text);
11083 4d12a6785531 util.stanza: Support getting 'by' from util.error object Kim Alvefur <zash@zash.se> parents: 10717 diff changeset	275 assert.are.equal("this.test", r.tags[1].attr.by);
11087 cdd4684992f1 spec.stanza spec: Split up util.error related tests Kim Alvefur <zash@zash.se> parents: 11086 diff changeset	276 end);
11084 5e09a3389adb util.stanza: Support inclusion of <gone> URI from util.error object Kim Alvefur <zash@zash.se> parents: 11083 diff changeset	277
11087 cdd4684992f1 spec.stanza spec: Split up util.error related tests Kim Alvefur <zash@zash.se> parents: 11086 diff changeset	278 it("should accept util.error objects with an URI", function ()
cdd4684992f1 spec.stanza spec: Split up util.error related tests Kim Alvefur <zash@zash.se> parents: 11086 diff changeset	279 local s = st.message({ to = "touser", from = "fromuser", id = "123", type = "chat" }, "Hello");
11084 5e09a3389adb util.stanza: Support inclusion of <gone> URI from util.error object Kim Alvefur <zash@zash.se> parents: 11083 diff changeset	280 local gone = errors.new({ condition = "gone", extra = { uri = "file:///dev/null" } })
5e09a3389adb util.stanza: Support inclusion of <gone> URI from util.error object Kim Alvefur <zash@zash.se> parents: 11083 diff changeset	281 local gonner = st.error_reply(s, gone);
5e09a3389adb util.stanza: Support inclusion of <gone> URI from util.error object Kim Alvefur <zash@zash.se> parents: 11083 diff changeset	282 assert.are.equal("gone", gonner.tags[1].tags[1].name);
5e09a3389adb util.stanza: Support inclusion of <gone> URI from util.error object Kim Alvefur <zash@zash.se> parents: 11083 diff changeset	283 assert.are.equal("file:///dev/null", gonner.tags[1].tags[1][1]);
11087 cdd4684992f1 spec.stanza spec: Split up util.error related tests Kim Alvefur <zash@zash.se> parents: 11086 diff changeset	284 end);
11086 2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	285
11087 cdd4684992f1 spec.stanza spec: Split up util.error related tests Kim Alvefur <zash@zash.se> parents: 11086 diff changeset	286 it("should accept util.error objects with application specific error", function ()
cdd4684992f1 spec.stanza spec: Split up util.error related tests Kim Alvefur <zash@zash.se> parents: 11086 diff changeset	287 local s = st.message({ to = "touser", from = "fromuser", id = "123", type = "chat" }, "Hello");
11086 2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	288 local e = errors.new({ condition = "internal-server-error", text = "Namespaced thing happened",
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	289 extra = {namespace="xmpp:example.test", condition="this-happened"} })
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	290 local r = st.error_reply(s, e);
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	291 assert.are.equal("xmpp:example.test", r.tags[1].tags[3].attr.xmlns);
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	292 assert.are.equal("this-happened", r.tags[1].tags[3].name);
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	293
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	294 local e2 = errors.new({ condition = "internal-server-error", text = "Namespaced thing happened",
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	295 extra = {tag=st.stanza("that-happened", { xmlns = "xmpp:example.test", ["another-attribute"] = "here" })} })
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	296 local r2 = st.error_reply(s, e2);
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	297 assert.are.equal("xmpp:example.test", r2.tags[1].tags[3].attr.xmlns);
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	298 assert.are.equal("that-happened", r2.tags[1].tags[3].name);
2846b6226a8e util.stanza: Support Application-Specific Conditions in util.error Kim Alvefur <zash@zash.se> parents: 11085 diff changeset	299 assert.are.equal("here", r2.tags[1].tags[3].attr["another-attribute"]);
10503 e25a1a9a6e7e util.stanza: Accept util.error object to error_reply Kim Alvefur <zash@zash.se> parents: 10446 diff changeset	300 end);
11087 cdd4684992f1 spec.stanza spec: Split up util.error related tests Kim Alvefur <zash@zash.se> parents: 11086 diff changeset	301 end);
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	302 end);
8599 62bfc85a53c8 util.stanza: Add stricter validation for data passed to stanza builder API Matthew Wild <mwild1@gmail.com> parents: 8598 diff changeset	303
11088 1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	304 describe("#get_error()", function ()
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	305 describe("basics", function ()
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	306 local s = st.message();
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	307 local e = st.error_reply(s, "cancel", "not-acceptable", "UNACCEPTABLE!!!! ONE MILLION YEARS DUNGEON!")
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	308 :tag("dungeon", { xmlns = "urn:uuid:c9026187-5b05-4e70-b265-c3b6338a7d0f", period="1000000years"});
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	309 local typ, cond, text, extra = e:get_error();
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	310 assert.equal("cancel", typ);
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	311 assert.equal("not-acceptable", cond);
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	312 assert.equal("UNACCEPTABLE!!!! ONE MILLION YEARS DUNGEON!", text);
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	313 assert.not_nil(extra)
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	314 end)
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	315 end)
1f84d0e4d0c4 util.stanza: Extract Application-Specific Condition from errors Kim Alvefur <zash@zash.se> parents: 11087 diff changeset	316
12687 5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	317 describe("#add_error()", function ()
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	318 describe("basics", function ()
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	319 local s = st.stanza("custom", { xmlns = "urn:example:foo" });
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	320 local e = s:add_error("cancel", "not-acceptable", "UNACCEPTABLE!!!! ONE MILLION YEARS DUNGEON!")
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	321 :tag("dungeon", { xmlns = "urn:uuid:c9026187-5b05-4e70-b265-c3b6338a7d0f", period="1000000years"});
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	322 assert.equal(s, e);
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	323 local typ, cond, text, extra = e:get_error();
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	324 assert.equal("cancel", typ);
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	325 assert.equal("not-acceptable", cond);
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	326 assert.equal("UNACCEPTABLE!!!! ONE MILLION YEARS DUNGEON!", text);
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	327 assert.is_nil(extra);
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	328 end)
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	329 end)
5b69ecaf3427 util.stanza: Add add_error() to simplify adding error tags to existing stanzas Matthew Wild <mwild1@gmail.com> parents: 12141 diff changeset	330
8626 20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	331 describe("should reject #invalid", function ()
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	332 local invalid_names = {
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	333 ["empty string"] = "", ["characters"] = "<>";
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	334 }
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	335 local invalid_data = {
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	336 ["number"] = 1234, ["table"] = {};
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	337 ["utf8"] = string.char(0xF4, 0x90, 0x80, 0x80);
8641 c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	338 ["nil"] = "nil"; ["boolean"] = true;
11205 9d1e21c23784 util.stanza: Reject ASCII control characters (fixes #1606) Kim Alvefur <zash@zash.se> parents: 9673 diff changeset	339 ["control characters"] = "\0\1\2\3";
8626 20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	340 };
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	341
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	342 for value_type, value in pairs(invalid_names) do
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	343 it(value_type.." in tag names", function ()
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	344 assert.error_matches(function ()
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	345 st.stanza(value);
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	346 end, value_type);
8599 62bfc85a53c8 util.stanza: Add stricter validation for data passed to stanza builder API Matthew Wild <mwild1@gmail.com> parents: 8598 diff changeset	347 end);
8626 20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	348 it(value_type.." in attribute names", function ()
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	349 assert.error_matches(function ()
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	350 st.stanza("valid", { [value] = "valid" });
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	351 end, value_type);
8599 62bfc85a53c8 util.stanza: Add stricter validation for data passed to stanza builder API Matthew Wild <mwild1@gmail.com> parents: 8598 diff changeset	352 end);
8626 20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	353 end
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	354 for value_type, value in pairs(invalid_data) do
8641 c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	355 if value == "nil" then value = nil; end
8626 20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	356 it(value_type.." in tag names", function ()
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	357 assert.error_matches(function ()
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	358 st.stanza(value);
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	359 end, value_type);
8599 62bfc85a53c8 util.stanza: Add stricter validation for data passed to stanza builder API Matthew Wild <mwild1@gmail.com> parents: 8598 diff changeset	360 end);
8626 20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	361 it(value_type.." in attribute names", function ()
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	362 assert.error_matches(function ()
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	363 st.stanza("valid", { [value] = "valid" });
20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	364 end, value_type);
8599 62bfc85a53c8 util.stanza: Add stricter validation for data passed to stanza builder API Matthew Wild <mwild1@gmail.com> parents: 8598 diff changeset	365 end);
8641 c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	366 if value ~= nil then
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	367 it(value_type.." in attribute values", function ()
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	368 assert.error_matches(function ()
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	369 st.stanza("valid", { valid = value });
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	370 end, value_type);
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	371 end);
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	372 it(value_type.." in text node", function ()
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	373 assert.error_matches(function ()
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	374 st.stanza("valid"):text(value);
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	375 end, value_type);
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	376 end);
c7734b59506f util.stanza: tests: Add more invalid data types and update for :text(nil) and :text("") Matthew Wild <mwild1@gmail.com> parents: 8626 diff changeset	377 end
8626 20532f191f8d util.stanza: Switch from asserts to if's, improve performance, errors and tests Matthew Wild <mwild1@gmail.com> parents: 8621 diff changeset	378 end
8599 62bfc85a53c8 util.stanza: Add stricter validation for data passed to stanza builder API Matthew Wild <mwild1@gmail.com> parents: 8598 diff changeset	379 end);
8621 e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	380
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	381 describe("#is_stanza", function ()
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	382 -- is_stanza(any) -> boolean
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	383 it("identifies stanzas as stanzas", function ()
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	384 assert.truthy(st.is_stanza(st.stanza("x")));
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	385 end);
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	386 it("identifies strings as not stanzas", function ()
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	387 assert.falsy(st.is_stanza(""));
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	388 end);
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	389 it("identifies numbers as not stanzas", function ()
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	390 assert.falsy(st.is_stanza(1));
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	391 end);
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	392 it("identifies tables as not stanzas", function ()
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	393 assert.falsy(st.is_stanza({}));
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	394 end);
e3e9479d526e util.stanza: Test coverage of is_stanza() Kim Alvefur <zash@zash.se> parents: 8599 diff changeset	395 end);
9000 4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	396
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	397 describe("#remove_children", function ()
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	398 it("should work", function ()
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	399 local s = st.stanza("x", {xmlns="test"})
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	400 :tag("y", {xmlns="test"}):up()
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	401 :tag("z", {xmlns="test2"}):up()
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	402 :tag("x", {xmlns="test2"}):up()
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	403
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	404 s:remove_children("x");
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	405 assert.falsy(s:get_child("x"))
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	406 assert.truthy(s:get_child("z","test2"));
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	407 assert.truthy(s:get_child("x","test2"));
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	408
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	409 s:remove_children(nil, "test2");
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	410 assert.truthy(s:get_child("y"))
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	411 assert.falsy(s:get_child(nil,"test2"));
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	412
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	413 s:remove_children();
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	414 assert.falsy(s.tags[1]);
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	415 end);
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	416 end);
4d64ff0719a6 util.stanza: Brief tests for :remove_children Kim Alvefur <zash@zash.se> parents: 8641 diff changeset	417
9216 ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	418 describe("#maptags", function ()
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	419 it("should work", function ()
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	420 local s = st.stanza("test")
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	421 :tag("one"):up()
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	422 :tag("two"):up()
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	423 :tag("one"):up()
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	424 :tag("three"):up();
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	425
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	426 local function one_filter(tag)
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	427 if tag.name == "one" then
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	428 return nil;
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	429 end
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	430 return tag;
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	431 end
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	432 assert.equal(4, #s.tags);
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	433 s:maptags(one_filter);
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	434 assert.equal(2, #s.tags);
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	435 end);
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	436
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	437 it("should work with multiple consecutive text nodes", function ()
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	438 local s = st.deserialize({
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	439 "\n";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	440 {
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	441 "away";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	442 name = "show";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	443 attr = {};
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	444 };
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	445 "\n";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	446 {
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	447 "I am away";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	448 name = "status";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	449 attr = {};
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	450 };
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	451 "\n";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	452 {
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	453 "0";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	454 name = "priority";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	455 attr = {};
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	456 };
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	457 "\n";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	458 {
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	459 name = "c";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	460 attr = {
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	461 xmlns = "http://jabber.org/protocol/caps";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	462 node = "http://psi-im.org";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	463 hash = "sha-1";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	464 };
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	465 };
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	466 "\n";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	467 "\n";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	468 name = "presence";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	469 attr = {
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	470 to = "user@example.com/jflsjfld";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	471 from = "room@chat.example.org/nick";
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	472 };
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	473 });
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	474
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	475 assert.equal(4, #s.tags);
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	476
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	477 s:maptags(function (tag) return tag; end);
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	478 assert.equal(4, #s.tags);
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	479
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	480 s:maptags(function (tag)
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	481 if tag.name == "c" then
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	482 return nil;
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	483 end
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	484 return tag;
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	485 end);
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	486 assert.equal(3, #s.tags);
ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	487 end);
9217 7df29c5fbb9b util.stanza + tests: Bail out of loop if we are iterating too far, fixes #981 Matthew Wild <mwild1@gmail.com> parents: 9216 diff changeset	488 it("errors on invalid data - #981", function ()
7df29c5fbb9b util.stanza + tests: Bail out of loop if we are iterating too far, fixes #981 Matthew Wild <mwild1@gmail.com> parents: 9216 diff changeset	489 local s = st.message({}, "Hello");
7df29c5fbb9b util.stanza + tests: Bail out of loop if we are iterating too far, fixes #981 Matthew Wild <mwild1@gmail.com> parents: 9216 diff changeset	490 s.tags[1] = st.clone(s.tags[1]);
7df29c5fbb9b util.stanza + tests: Bail out of loop if we are iterating too far, fixes #981 Matthew Wild <mwild1@gmail.com> parents: 9216 diff changeset	491 assert.has_error_match(function ()
7df29c5fbb9b util.stanza + tests: Bail out of loop if we are iterating too far, fixes #981 Matthew Wild <mwild1@gmail.com> parents: 9216 diff changeset	492 s:maptags(function () end);
7df29c5fbb9b util.stanza + tests: Bail out of loop if we are iterating too far, fixes #981 Matthew Wild <mwild1@gmail.com> parents: 9216 diff changeset	493 end, "Invalid stanza");
7df29c5fbb9b util.stanza + tests: Bail out of loop if we are iterating too far, fixes #981 Matthew Wild <mwild1@gmail.com> parents: 9216 diff changeset	494 end);
9216 ba38a947020e util.stanza tests: Add tests for maptags() method Matthew Wild <mwild1@gmail.com> parents: 9000 diff changeset	495 end);
9630 bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	496
11786 39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	497 describe("get_child_with_attr", function ()
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	498 local s = st.message({ type = "chat" })
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	499 :text_tag("body", "Hello world", { ["xml:lang"] = "en" })
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	500 :text_tag("body", "Bonjour le monde", { ["xml:lang"] = "fr" })
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	501 :text_tag("body", "Hallo Welt", { ["xml:lang"] = "de" })
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	502
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	503 it("works", function ()
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	504 assert.equal(s:get_child_with_attr("body", nil, "xml:lang", "en"):get_text(), "Hello world");
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	505 assert.equal(s:get_child_with_attr("body", nil, "xml:lang", "de"):get_text(), "Hallo Welt");
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	506 assert.equal(s:get_child_with_attr("body", nil, "xml:lang", "fr"):get_text(), "Bonjour le monde");
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	507 assert.is_nil(s:get_child_with_attr("body", nil, "xml:lang", "FR"));
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	508 assert.is_nil(s:get_child_with_attr("body", nil, "xml:lang", "es"));
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	509 end);
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	510
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	511 it("supports normalization", function ()
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	512 assert.equal(s:get_child_with_attr("body", nil, "xml:lang", "EN", string.upper):get_text(), "Hello world");
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	513 assert.is_nil(s:get_child_with_attr("body", nil, "xml:lang", "ES", string.upper));
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	514 end);
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	515 end);
39164ea2ab9e util.stanza: Add :get_child_with_attr() + tests Matthew Wild <mwild1@gmail.com> parents: 11206 diff changeset	516
9630 bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	517 describe("#clone", function ()
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	518 it("works", function ()
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	519 local s = st.message({type="chat"}, "Hello"):reset();
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	520 local c = st.clone(s);
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	521 assert.same(s, c);
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	522 end);
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	523
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	524 it("works", function ()
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	525 assert.has_error(function ()
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	526 st.clone("this is not a stanza");
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	527 end);
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	528 end);
bff66c3faceb util.stanza: Validate input to clone() (with brief tests) Kim Alvefur <zash@zash.se> parents: 9308 diff changeset	529 end);
9924 5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	530
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	531 describe("top_tag", function ()
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	532 local xml_parse = require "util.xml".parse;
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	533 it("works", function ()
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	534 local s = st.message({type="chat"}, "Hello");
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	535 local top_tag = s:top_tag();
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	536 assert.is_string(top_tag);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	537 assert.not_equal("/>", top_tag:sub(-2, -1));
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	538 assert.equal(">", top_tag:sub(-1, -1));
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	539 local s2 = xml_parse(top_tag.."</message>");
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	540 assert(st.is_stanza(s2));
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	541 assert.equal("message", s2.name);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	542 assert.equal(0, #s2);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	543 assert.equal(0, #s2.tags);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	544 assert.equal("chat", s2.attr.type);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	545 end);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	546
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	547 it("works with namespaced attributes", function ()
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	548 local s = xml_parse[[<message foo:bar='true' xmlns:foo='my-awesome-ns'/>]];
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	549 local top_tag = s:top_tag();
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	550 assert.is_string(top_tag);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	551 assert.not_equal("/>", top_tag:sub(-2, -1));
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	552 assert.equal(">", top_tag:sub(-1, -1));
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	553 local s2 = xml_parse(top_tag.."</message>");
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	554 assert(st.is_stanza(s2));
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	555 assert.equal("message", s2.name);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	556 assert.equal(0, #s2);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	557 assert.equal(0, #s2.tags);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	558 assert.equal("true", s2.attr["my-awesome-ns\1bar"]);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	559 end);
5a2e53bef031 util.stanza: Fix :top_tag() handling of namespaced attributes Matthew Wild <mwild1@gmail.com> parents: 9732 diff changeset	560 end);
10717 05e4645fc9b3 util.stanza: Add method returning stanza with added indentation Kim Alvefur <zash@zash.se> parents: 10503 diff changeset	561
05e4645fc9b3 util.stanza: Add method returning stanza with added indentation Kim Alvefur <zash@zash.se> parents: 10503 diff changeset	562 describe("indent", function ()
05e4645fc9b3 util.stanza: Add method returning stanza with added indentation Kim Alvefur <zash@zash.se> parents: 10503 diff changeset	563 local s = st.stanza("foo"):text("\n"):tag("bar"):tag("baz"):up():text_tag("cow", "moo");
05e4645fc9b3 util.stanza: Add method returning stanza with added indentation Kim Alvefur <zash@zash.se> parents: 10503 diff changeset	564 assert.equal("<foo>\n\t<bar>\n\t\t<baz/>\n\t\t<cow>moo</cow>\n\t</bar>\n</foo>", tostring(s:indent()));
05e4645fc9b3 util.stanza: Add method returning stanza with added indentation Kim Alvefur <zash@zash.se> parents: 10503 diff changeset	565 assert.equal("<foo>\n <bar>\n <baz/>\n <cow>moo</cow>\n </bar>\n</foo>", tostring(s:indent(1, " ")));
05e4645fc9b3 util.stanza: Add method returning stanza with added indentation Kim Alvefur <zash@zash.se> parents: 10503 diff changeset	566 assert.equal("<foo>\n\t\t<bar>\n\t\t\t<baz/>\n\t\t\t<cow>moo</cow>\n\t\t</bar>\n\t</foo>", tostring(s:indent(2, "\t")));
05e4645fc9b3 util.stanza: Add method returning stanza with added indentation Kim Alvefur <zash@zash.se> parents: 10503 diff changeset	567 end);
05e4645fc9b3 util.stanza: Add method returning stanza with added indentation Kim Alvefur <zash@zash.se> parents: 10503 diff changeset	568
12141 3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	569 describe("find", function()
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	570 it("works", function()
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	571 local s = st.stanza("root", { attr = "value" }):tag("child",
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	572 { xmlns = "urn:example:not:same"; childattr = "thisvalue" }):text_tag("nested", "text"):reset();
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	573 assert.equal("value", s:find("@attr"), "finds attr")
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	574 assert.equal(s:get_child("child", "urn:example:not:same"), s:find("{urn:example:not:same}child"),
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	575 "equivalent to get_child")
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	576 assert.equal("thisvalue", s:find("{urn:example:not:same}child@childattr"), "finds child attr")
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	577 assert.equal("text", s:find("{urn:example:not:same}child/nested#"), "finds nested text")
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	578 assert.is_nil(s:find("child"), "respects namespaces")
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	579 end);
3ac801630b4b util.stanza: Cover :find method in tests Kim Alvefur <zash@zash.se> parents: 12139 diff changeset	580 end);
8236 4878e4159e12 Port tests to the `busted` test runner Waqas Hussain <waqas20@gmail.com> parents: diff changeset	581 end);

prosody

e732f9dfdfc8

spec/util_stanza_spec.lua

Software / code / prosody

Annotate

spec/util_stanza_spec.lua @ 13055:e732f9dfdfc8

Software `/` code `/` prosody