prosody
06453c564141
spec/util_stanza_spec.lua

Find changesets by keywords by author, files, the commit message, revision number or hash, or revset expression.

Software / code / prosody

Annotate

spec/util_stanza_spec.lua @ 13014:06453c564141

util.startup: Add prosody.started promise to easily execute code after startup To avoid a race where server-started fires before the promise function body is run (on next tick), I moved server-started to fire on the next tick, which seems sensible anyway. Errors are logged, I'm not sure if we ought to be doing something more here. I'm sure we'll find out.
author Matthew Wild <mwild1@gmail.com>
date Sat, 01 Apr 2023 11:56:38 +0100
parent 12687:5b69ecaf3427
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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);