Mercurial > prosody-hg

annotate spec/core_storagemanager_spec.lua @ 13946:f5e8ab42c708

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
mod_http_file_share: Check that files are still there with correct size Failed uploads can leave behind unused slots. Files shouldn't change size after they have been successfully uploaded, but might as well double check it.
author Kim Alvefur <zash@zash.se>
date Sat, 04 Dec 2021 18:56:51 +0100
parents cbd234461c41
children f77911437539
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
12589
39ae08180c81 compat: Remove handling of Lua 5.1 location of 'unpack' function
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
1 local unpack = table.unpack;
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
2
13243
c5ccdfbbe9c1 tests: Update storagemanager tests for prosody.* namespace change
Kim Alvefur <zash@zash.se>
parents: 13133
diff changeset
3 local st = require "prosody.util.stanza";
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
4
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
5 local function mock_prosody()
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
6 _G.prosody = {
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
7 core_post_stanza = function () end;
13243
c5ccdfbbe9c1 tests: Update storagemanager tests for prosody.* namespace change
Kim Alvefur <zash@zash.se>
parents: 13133
diff changeset
8 events = require "prosody.util.events".new();
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
9 hosts = {};
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
10 paths = {
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
11 data = "./data";
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
12 };
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
13 };
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
14 end
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
15
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
16 local configs = {
9491
89e4cbd1a564 storagemanager tests: Also cover memory driver
Kim Alvefur <zash@zash.se>
parents: 9472
diff changeset
17 memory = {
89e4cbd1a564 storagemanager tests: Also cover memory driver
Kim Alvefur <zash@zash.se>
parents: 9472
diff changeset
18 storage = "memory";
89e4cbd1a564 storagemanager tests: Also cover memory driver
Kim Alvefur <zash@zash.se>
parents: 9472
diff changeset
19 };
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
20 internal = {
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
21 storage = "internal";
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
22 };
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
23 sqlite = {
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
24 storage = "sql";
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
25 sql = { driver = "SQLite3", database = "prosody-tests.sqlite" };
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
26 };
9452
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
27 mysql = {
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
28 storage = "sql";
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
29 sql = { driver = "MySQL", database = "prosody", username = "prosody", password = "secret", host = "localhost" };
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
30 };
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
31 postgres = {
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
32 storage = "sql";
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
33 sql = { driver = "PostgreSQL", database = "prosody", username = "prosody", password = "secret", host = "localhost" };
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
34 };
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
35 };
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
36
13244
2902c54f45a6 tests: Add hack to test only a single storage driver
Kim Alvefur <zash@zash.se>
parents: 13243
diff changeset
37 local test_only_driver = os.getenv "PROSODY_TEST_ONLY_STORAGE";
2902c54f45a6 tests: Add hack to test only a single storage driver
Kim Alvefur <zash@zash.se>
parents: 13243
diff changeset
38 if test_only_driver then
2902c54f45a6 tests: Add hack to test only a single storage driver
Kim Alvefur <zash@zash.se>
parents: 13243
diff changeset
39 configs = { [test_only_driver] = configs[test_only_driver] }
2902c54f45a6 tests: Add hack to test only a single storage driver
Kim Alvefur <zash@zash.se>
parents: 13243
diff changeset
40 end
2902c54f45a6 tests: Add hack to test only a single storage driver
Kim Alvefur <zash@zash.se>
parents: 13243
diff changeset
41
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
42 local test_host = "storage-unit-tests.invalid";
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
43
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
44 describe("storagemanager", function ()
9452
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
45 for backend, backend_config in pairs(configs) do
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
46 local tagged_name = "#"..backend;
9452
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
47 if backend ~= backend_config.storage then
9d892b2415bf Fix storage tests so they run, but not by default
Matthew Wild <mwild1@gmail.com>
parents: 9389
diff changeset
48 tagged_name = tagged_name.." #"..backend_config.storage;
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
49 end
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
50 insulate(tagged_name.." #storage backend", function ()
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
51 mock_prosody();
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
52
13243
c5ccdfbbe9c1 tests: Update storagemanager tests for prosody.* namespace change
Kim Alvefur <zash@zash.se>
parents: 13133
diff changeset
53 local config = require "prosody.core.configmanager";
c5ccdfbbe9c1 tests: Update storagemanager tests for prosody.* namespace change
Kim Alvefur <zash@zash.se>
parents: 13133
diff changeset
54 local sm = require "prosody.core.storagemanager";
c5ccdfbbe9c1 tests: Update storagemanager tests for prosody.* namespace change
Kim Alvefur <zash@zash.se>
parents: 13133
diff changeset
55 local hm = require "prosody.core.hostmanager";
c5ccdfbbe9c1 tests: Update storagemanager tests for prosody.* namespace change
Kim Alvefur <zash@zash.se>
parents: 13133
diff changeset
56 local mm = require "prosody.core.modulemanager";
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
57
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
58 -- Simple check to ensure insulation is working correctly
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
59 assert.is_nil(config.get(test_host, "storage"));
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
60
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
61 for k, v in pairs(backend_config) do
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
62 config.set(test_host, k, v);
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
63 end
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
64 assert(hm.activate(test_host, {}));
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
65 sm.initialize_host(test_host);
13781
97bbe60336bc core.storagemanager: Fix tests by removing an assert that upset luarocks
Kim Alvefur <zash@zash.se>
parents: 13402
diff changeset
66 mm.load(test_host, "storage_"..backend_config.storage);
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
67
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
68 describe("key-value stores", function ()
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
69 -- These tests rely on being executed in order, disable any order
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
70 -- randomization for this block
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
71 randomize(false);
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
72
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
73 local store;
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
74 it("may be opened", function ()
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
75 store = assert(sm.open(test_host, "test"));
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
76 end);
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
77
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
78 local simple_data = { foo = "bar" };
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
79
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
80 it("may set data for a user", function ()
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
81 assert(store:set("user9999", simple_data));
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
82 end);
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
83
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
84 it("may get data for a user", function ()
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
85 assert.same(simple_data, assert(store:get("user9999")));
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
86 end);
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
87
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
88 it("may remove data for a user", function ()
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
89 assert(store:set("user9999", nil));
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
90 local ret, err = store:get("user9999");
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
91 assert.is_nil(ret);
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
92 assert.is_nil(err);
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
93 end);
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
94 end);
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
95
10676
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
96 describe("map stores", function ()
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
97 -- These tests rely on being executed in order, disable any order
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
98 -- randomization for this block
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
99 randomize(false);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
100
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
101 local store, kv_store;
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
102 it("may be opened", function ()
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
103 store = assert(sm.open(test_host, "test-map", "map"));
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
104 end);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
105
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
106 it("may be opened as a keyval store", function ()
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
107 kv_store = assert(sm.open(test_host, "test-map", "keyval"));
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
108 end);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
109
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
110 it("may set a specific key for a user", function ()
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
111 assert(store:set("user9999", "foo", "bar"));
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
112 assert.same(kv_store:get("user9999"), { foo = "bar" });
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
113 end);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
114
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
115 it("may get a specific key for a user", function ()
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
116 assert.equal("bar", store:get("user9999", "foo"));
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
117 end);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
118
10679
b50b1eae711c storagemanager: Add support for :find_key() and :delete_key() to map store shim
Matthew Wild <mwild1@gmail.com>
parents: 10678
diff changeset
119 it("may find all users with a specific key", function ()
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
120 assert.is_function(store.get_all);
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
121 assert(store:set("user9999b", "bar", "bar"));
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
122 assert(store:set("user9999c", "foo", "blah"));
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
123 local ret, err = store:get_all("foo");
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
124 assert.is_nil(err);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
125 assert.same({ user9999 = "bar", user9999c = "blah" }, ret);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
126 end);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
127
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
128 it("rejects empty or non-string keys to get_all", function ()
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
129 assert.is_function(store.get_all);
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
130 do
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
131 local ret, err = store:get_all("");
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
132 assert.is_nil(ret);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
133 assert.is_not_nil(err);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
134 end
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
135 do
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
136 local ret, err = store:get_all(true);
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
137 assert.is_nil(ret);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
138 assert.is_not_nil(err);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
139 end
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
140 end);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
141
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
142 it("rejects empty or non-string keys to delete_all", function ()
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
143 assert.is_function(store.delete_all);
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
144 do
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
145 local ret, err = store:delete_all("");
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
146 assert.is_nil(ret);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
147 assert.is_not_nil(err);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
148 end
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
149 do
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
150 local ret, err = store:delete_all(true);
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
151 assert.is_nil(ret);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
152 assert.is_not_nil(err);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
153 end
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
154 end);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
155
10679
b50b1eae711c storagemanager: Add support for :find_key() and :delete_key() to map store shim
Matthew Wild <mwild1@gmail.com>
parents: 10678
diff changeset
156 it("may delete all instances of a specific key", function ()
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
157 assert.is_function(store.delete_all);
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
158 assert(store:set("user9999b", "foo", "hello"));
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
159
10680
19692fc5c106 storagemanager, mod_storage_sql: Rename methods to :get_all() and :delete_all()
Matthew Wild <mwild1@gmail.com>
parents: 10679
diff changeset
160 assert(store:delete_all("bar"));
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
161 -- Ensure key was deleted
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
162 do
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
163 local ret, err = store:get("user9999b", "bar");
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
164 assert.is_nil(ret);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
165 assert.is_nil(err);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
166 end
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
167 -- Ensure other users/keys are intact
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
168 do
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
169 local ret, err = store:get("user9999", "foo");
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
170 assert.equal("bar", ret);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
171 assert.is_nil(err);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
172 end
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
173 do
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
174 local ret, err = store:get("user9999b", "foo");
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
175 assert.equal("hello", ret);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
176 assert.is_nil(err);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
177 end
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
178 do
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
179 local ret, err = store:get("user9999c", "foo");
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
180 assert.equal("blah", ret);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
181 assert.is_nil(err);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
182 end
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
183 end);
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
184
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
185 it("may remove data for a specific key for a user", function ()
10676
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
186 assert(store:set("user9999", "foo", nil));
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
187 do
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
188 local ret, err = store:get("user9999", "foo");
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
189 assert.is_nil(ret);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
190 assert.is_nil(err);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
191 end
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
192
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
193 assert(store:set("user9999b", "foo", nil));
10676
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
194 do
10677
0054aec3e8c5 mod_storage_sql: Add map_store:find_key() and map_store:delete_key() (+ tests)
Matthew Wild <mwild1@gmail.com>
parents: 10676
diff changeset
195 local ret, err = store:get("user9999b", "foo");
10676
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
196 assert.is_nil(ret);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
197 assert.is_nil(err);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
198 end
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
199 end);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
200 end);
33c7e4920591 storagemanager: Add tests for map stores
Matthew Wild <mwild1@gmail.com>
parents: 10541
diff changeset
201
12956
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
202 describe("keyval+ stores", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
203 -- These tests rely on being executed in order, disable any order
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
204 -- randomization for this block
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
205 randomize(false);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
206
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
207 local store, kv_store, map_store;
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
208 it("may be opened", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
209 store = assert(sm.open(test_host, "test-kv+", "keyval+"));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
210 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
211
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
212 local simple_data = { foo = "bar" };
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
213
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
214 it("may set data for a user", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
215 assert(store:set("user9999", simple_data));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
216 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
217
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
218 it("may get data for a user", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
219 assert.same(simple_data, assert(store:get("user9999")));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
220 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
221
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
222 it("may be opened as a keyval store", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
223 kv_store = assert(sm.open(test_host, "test-kv+", "keyval"));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
224 assert.same(simple_data, assert(kv_store:get("user9999")));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
225 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
226
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
227 it("may be opened as a map store", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
228 map_store = assert(sm.open(test_host, "test-kv+", "map"));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
229 assert.same("bar", assert(map_store:get("user9999", "foo")));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
230 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
231
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
232 it("may remove data for a user", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
233 assert(store:set("user9999", nil));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
234 local ret, err = store:get("user9999");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
235 assert.is_nil(ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
236 assert.is_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
237 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
238
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
239
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
240 it("may set a specific key for a user", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
241 assert(store:set_key("user9999", "foo", "bar"));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
242 assert.same(kv_store:get("user9999"), { foo = "bar" });
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
243 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
244
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
245 it("may get a specific key for a user", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
246 assert.equal("bar", store:get_key("user9999", "foo"));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
247 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
248
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
249 it("may find all users with a specific key", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
250 assert.is_function(store.get_key_from_all);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
251 assert(store:set_key("user9999b", "bar", "bar"));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
252 assert(store:set_key("user9999c", "foo", "blah"));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
253 local ret, err = store:get_key_from_all("foo");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
254 assert.is_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
255 assert.same({ user9999 = "bar", user9999c = "blah" }, ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
256 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
257
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
258 it("rejects empty or non-string keys to get_all", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
259 assert.is_function(store.get_key_from_all);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
260 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
261 local ret, err = store:get_key_from_all("");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
262 assert.is_nil(ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
263 assert.is_not_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
264 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
265 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
266 local ret, err = store:get_key_from_all(true);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
267 assert.is_nil(ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
268 assert.is_not_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
269 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
270 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
271
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
272 it("rejects empty or non-string keys to delete_all", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
273 assert.is_function(store.delete_key_from_all);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
274 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
275 local ret, err = store:delete_key_from_all("");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
276 assert.is_nil(ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
277 assert.is_not_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
278 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
279 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
280 local ret, err = store:delete_key_from_all(true);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
281 assert.is_nil(ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
282 assert.is_not_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
283 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
284 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
285
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
286 it("may delete all instances of a specific key", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
287 assert.is_function(store.delete_key_from_all);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
288 assert(store:set_key("user9999b", "foo", "hello"));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
289
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
290 assert(store:delete_key_from_all("bar"));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
291 -- Ensure key was deleted
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
292 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
293 local ret, err = store:get_key("user9999b", "bar");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
294 assert.is_nil(ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
295 assert.is_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
296 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
297 -- Ensure other users/keys are intact
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
298 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
299 local ret, err = store:get_key("user9999", "foo");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
300 assert.equal("bar", ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
301 assert.is_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
302 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
303 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
304 local ret, err = store:get_key("user9999b", "foo");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
305 assert.equal("hello", ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
306 assert.is_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
307 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
308 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
309 local ret, err = store:get_key("user9999c", "foo");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
310 assert.equal("blah", ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
311 assert.is_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
312 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
313 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
314
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
315 it("may remove data for a specific key for a user", function ()
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
316 assert(store:set_key("user9999", "foo", nil));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
317 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
318 local ret, err = store:get_key("user9999", "foo");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
319 assert.is_nil(ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
320 assert.is_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
321 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
322
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
323 assert(store:set_key("user9999b", "foo", nil));
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
324 do
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
325 local ret, err = store:get_key("user9999b", "foo");
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
326 assert.is_nil(ret);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
327 assert.is_nil(err);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
328 end
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
329 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
330 end);
52fcdfe710ca storagemanager: Add keyval+ (combined keyval + map) store type
Matthew Wild <mwild1@gmail.com>
parents: 12600
diff changeset
331
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
332 describe("archive stores", function ()
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
333 randomize(false);
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
334
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
335 local archive;
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
336 it("can be opened", function ()
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
337 archive = assert(sm.open(test_host, "test-archive", "archive"));
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
338 end);
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
339
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
340 local test_stanza = st.stanza("test", { xmlns = "urn:example:foo" })
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
341 :tag("foo"):up()
10836
93019f3edd68 spec/storage: Reset build context of test stanza make comparisons easier
Kim Alvefur <zash@zash.se>
parents: 10680
diff changeset
342 :tag("foo"):up()
93019f3edd68 spec/storage: Reset build context of test stanza make comparisons easier
Kim Alvefur <zash@zash.se>
parents: 10680
diff changeset
343 :reset();
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
344 local test_time = 1539204123;
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
345
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
346 local test_data = {
13133
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
347 { nil, test_stanza, test_time-3, "contact@example.com" };
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
348 { nil, test_stanza, test_time-2, "contact2@example.com" };
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
349 { nil, test_stanza, test_time-1, "contact2@example.com" };
13133
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
350 { nil, test_stanza, test_time+0, "contact2@example.com" };
10927
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
351 { nil, test_stanza, test_time+1, "contact3@example.com" };
13133
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
352 { nil, test_stanza, test_time+2, "contact3@example.com" };
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
353 { nil, test_stanza, test_time+3, "contact3@example.com" };
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
354 };
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
355
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
356 it("can be added to", function ()
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
357 for _, data_item in ipairs(test_data) do
10927
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
358 local id = archive:append("user", unpack(data_item, 1, 4));
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
359 assert.truthy(id);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
360 data_item[1] = id;
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
361 end
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
362 end);
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
363
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
364 describe("can be queried", function ()
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
365 it("for all items", function ()
10541
6c6ff4509082 tests: Silence [luacheck] warnings
Kim Alvefur <zash@zash.se>
parents: 9691
diff changeset
366 -- luacheck: ignore 211/err
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
367 local data, err = archive:find("user", {});
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
368 assert.truthy(data);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
369 local count = 0;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
370 for id, item, when in data do
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
371 count = count + 1;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
372 assert.truthy(id);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
373 assert(st.is_stanza(item));
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
374 assert.equal("test", item.name);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
375 assert.equal("urn:example:foo", item.attr.xmlns);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
376 assert.equal(2, #item.tags);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
377 assert.equal(test_data[count][3], when);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
378 end
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
379 assert.equal(#test_data, count);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
380 end);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
381
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
382 it("by JID", function ()
10541
6c6ff4509082 tests: Silence [luacheck] warnings
Kim Alvefur <zash@zash.se>
parents: 9691
diff changeset
383 -- luacheck: ignore 211/err
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
384 local data, err = archive:find("user", {
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
385 with = "contact@example.com";
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
386 });
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
387 assert.truthy(data);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
388 local count = 0;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
389 for id, item, when in data do
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
390 count = count + 1;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
391 assert.truthy(id);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
392 assert(st.is_stanza(item));
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
393 assert.equal("test", item.name);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
394 assert.equal("urn:example:foo", item.attr.xmlns);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
395 assert.equal(2, #item.tags);
13133
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
396 assert.equal(test_time-3, when);
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
397 end
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
398 assert.equal(1, count);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
399 end);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
400
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
401 it("by time (end)", function ()
10541
6c6ff4509082 tests: Silence [luacheck] warnings
Kim Alvefur <zash@zash.se>
parents: 9691
diff changeset
402 -- luacheck: ignore 211/err
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
403 local data, err = archive:find("user", {
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
404 ["end"] = test_time;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
405 });
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
406 assert.truthy(data);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
407 local count = 0;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
408 for id, item, when in data do
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
409 count = count + 1;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
410 assert.truthy(id);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
411 assert(st.is_stanza(item));
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
412 assert.equal("test", item.name);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
413 assert.equal("urn:example:foo", item.attr.xmlns);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
414 assert.equal(2, #item.tags);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
415 assert(test_time >= when);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
416 end
10927
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
417 assert.equal(4, count);
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
418 end);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
419
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
420 it("by time (start)", function ()
10541
6c6ff4509082 tests: Silence [luacheck] warnings
Kim Alvefur <zash@zash.se>
parents: 9691
diff changeset
421 -- luacheck: ignore 211/err
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
422 local data, err = archive:find("user", {
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
423 ["start"] = test_time;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
424 });
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
425 assert.truthy(data);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
426 local count = 0;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
427 for id, item, when in data do
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
428 count = count + 1;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
429 assert.truthy(id);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
430 assert(st.is_stanza(item));
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
431 assert.equal("test", item.name);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
432 assert.equal("urn:example:foo", item.attr.xmlns);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
433 assert.equal(2, #item.tags);
13133
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
434 assert(when >= test_time, ("%d >= %d"):format(when, test_time));
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
435 end
13133
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
436 assert.equal(#test_data - 3, count);
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
437 end);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
438
13847
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
439 it("by time (start before first item)", function ()
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
440 -- luacheck: ignore 211/err
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
441 local data, err = archive:find("user", {
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
442 ["start"] = test_time-5;
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
443 });
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
444 assert.truthy(data);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
445 local count = 0;
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
446 for id, item, when in data do
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
447 count = count + 1;
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
448 assert.truthy(id);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
449 assert(st.is_stanza(item));
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
450 assert.equal("test", item.name);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
451 assert.equal("urn:example:foo", item.attr.xmlns);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
452 assert.equal(2, #item.tags);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
453 assert(when >= test_time-5, ("%d >= %d"):format(when, test_time-5));
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
454 end
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
455 assert.equal(#test_data, count);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
456 end);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
457
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
458 it("by time (start after last item)", function ()
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
459 -- luacheck: ignore 211/err
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
460 local data, err = archive:find("user", {
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
461 ["start"] = test_time+5;
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
462 });
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
463 assert.truthy(data);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
464 local count = 0;
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
465 for id, item, when in data do
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
466 count = count + 1;
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
467 assert.truthy(id);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
468 assert(st.is_stanza(item));
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
469 assert.equal("test", item.name);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
470 assert.equal("urn:example:foo", item.attr.xmlns);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
471 assert.equal(2, #item.tags);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
472 assert(when >= test_time+5, ("%d >= %d"):format(when, test_time+5));
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
473 end
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
474 assert.equal(0, count);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
475 end);
cbd234461c41 mod_storage_internal: Fix queries with only start returning extra items
Kim Alvefur <zash@zash.se>
parents: 13781
diff changeset
476
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
477 it("by time (start+end)", function ()
10541
6c6ff4509082 tests: Silence [luacheck] warnings
Kim Alvefur <zash@zash.se>
parents: 9691
diff changeset
478 -- luacheck: ignore 211/err
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
479 local data, err = archive:find("user", {
13133
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
480 ["start"] = test_time-1;
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
481 ["end"] = test_time+2;
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
482 });
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
483 assert.truthy(data);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
484 local count = 0;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
485 for id, item, when in data do
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
486 count = count + 1;
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
487 assert.truthy(id);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
488 assert(st.is_stanza(item));
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
489 assert.equal("test", item.name);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
490 assert.equal("urn:example:foo", item.attr.xmlns);
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
491 assert.equal(2, #item.tags);
13133
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
492 assert(when >= test_time-1, ("%d >= %d"):format(when, test_time));
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
493 assert(when <= test_time+2, ("%d <= %d"):format(when, test_time+1));
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
494 end
10927
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
495 assert.equal(4, count);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
496 end);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
497
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
498 it("by id (after)", function ()
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
499 -- luacheck: ignore 211/err
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
500 local data, err = archive:find("user", {
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
501 ["after"] = test_data[2][1];
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
502 });
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
503 assert.truthy(data);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
504 local count = 0;
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
505 for id, item in data do
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
506 count = count + 1;
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
507 assert.truthy(id);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
508 assert.equal(test_data[2+count][1], id);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
509 assert(st.is_stanza(item));
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
510 assert.equal("test", item.name);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
511 assert.equal("urn:example:foo", item.attr.xmlns);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
512 assert.equal(2, #item.tags);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
513 end
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
514 assert.equal(5, count);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
515 end);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
516
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
517 it("by id (before)", function ()
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
518 -- luacheck: ignore 211/err
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
519 local data, err = archive:find("user", {
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
520 ["before"] = test_data[4][1];
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
521 });
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
522 assert.truthy(data);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
523 local count = 0;
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
524 for id, item in data do
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
525 count = count + 1;
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
526 assert.truthy(id);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
527 assert.equal(test_data[count][1], id);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
528 assert(st.is_stanza(item));
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
529 assert.equal("test", item.name);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
530 assert.equal("urn:example:foo", item.attr.xmlns);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
531 assert.equal(2, #item.tags);
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
532 end
470602a8b633 storage tests: Add tests for archive queries before/after specific ids
Matthew Wild <mwild1@gmail.com>
parents: 10842
diff changeset
533 assert.equal(3, count);
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
534 end);
11273
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
535
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
536 it("by id (before and after) #full_id_range", function ()
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
537 assert.truthy(archive.caps and archive.caps.full_id_range, "full ID range support")
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
538 local data, err = archive:find("user", {
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
539 ["after"] = test_data[1][1];
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
540 ["before"] = test_data[4][1];
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
541 });
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
542 assert.truthy(data, err);
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
543 local count = 0;
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
544 for id, item in data do
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
545 count = count + 1;
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
546 assert.truthy(id);
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
547 assert.equal(test_data[1+count][1], id);
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
548 assert(st.is_stanza(item));
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
549 assert.equal("test", item.name);
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
550 assert.equal("urn:example:foo", item.attr.xmlns);
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
551 assert.equal(2, #item.tags);
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
552 end
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
553 assert.equal(2, count);
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
554 end);
9f1355689648 storage tests: Test querys with both before and after IDs
Kim Alvefur <zash@zash.se>
parents: 10927
diff changeset
555
11276
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
556 it("by multiple ids", function ()
11424
2358299bc928 core.storagemanager: s/Multilpe/Multiple/ [codespell]
Kim Alvefur <zash@zash.se>
parents: 11354
diff changeset
557 assert.truthy(archive.caps and archive.caps.ids, "Multiple ID query")
11276
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
558 local data, err = archive:find("user", {
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
559 ["ids"] = {
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
560 test_data[2][1];
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
561 test_data[4][1];
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
562 };
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
563 });
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
564 assert.truthy(data, err);
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
565 local count = 0;
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
566 for id, item in data do
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
567 count = count + 1;
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
568 assert.truthy(id);
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
569 assert.equal(test_data[count==1 and 2 or 4][1], id);
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
570 assert(st.is_stanza(item));
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
571 assert.equal("test", item.name);
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
572 assert.equal("urn:example:foo", item.attr.xmlns);
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
573 assert.equal(2, #item.tags);
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
574 end
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
575 assert.equal(2, count);
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
576
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
577 end);
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
578
7b2ee8995af9 storage tests: Add test for querying a set of IDs
Kim Alvefur <zash@zash.se>
parents: 11273
diff changeset
579
11353
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
580 it("can be queried in reverse", function ()
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
581
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
582 local data, err = archive:find("user", {
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
583 reverse = true;
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
584 limit = 3;
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
585 });
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
586 assert.truthy(data, err);
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
587
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
588 local i = #test_data;
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
589 for id, item in data do
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
590 assert.truthy(id);
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
591 assert.equal(test_data[i][1], id);
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
592 assert(st.is_stanza(item));
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
593 assert.equal("test", item.name);
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
594 assert.equal("urn:example:foo", item.attr.xmlns);
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
595 assert.equal(2, #item.tags);
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
596 i = i - 1;
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
597 end
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
598
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
599 end);
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
600
13402
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
601 -- This tests combines the reverse flag with 'before' and 'after' to
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
602 -- ensure behaviour remains correct
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
603 it("by id (before and after) in reverse #full_id_range", function ()
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
604 assert.truthy(archive.caps and archive.caps.full_id_range, "full ID range support")
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
605 local data, err = archive:find("user", {
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
606 ["after"] = test_data[1][1];
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
607 ["before"] = test_data[4][1];
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
608 reverse = true;
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
609 });
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
610 assert.truthy(data, err);
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
611 local count = 0;
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
612 for id, item in data do
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
613 count = count + 1;
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
614 assert.truthy(id);
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
615 assert.equal(test_data[4-count][1], id);
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
616 assert(st.is_stanza(item));
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
617 assert.equal("test", item.name);
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
618 assert.equal("urn:example:foo", item.attr.xmlns);
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
619 assert.equal(2, #item.tags);
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
620 end
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
621 assert.equal(2, count);
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
622 end);
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
623
6877786d73d7 mod_storage_internal, tests: Fix before/after combined with the 'reverse' flag
Matthew Wild <mwild1@gmail.com>
parents: 13244
diff changeset
624
11353
367e6beaf8ab storage: Test reverse-ordered queries
Kim Alvefur <zash@zash.se>
parents: 11276
diff changeset
625
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
626 end);
9470
0d491bc98b9f storagemanager tests: Add additional archive query tests
Matthew Wild <mwild1@gmail.com>
parents: 9467
diff changeset
627
9471
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
628 it("can selectively delete items", function ()
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
629 local delete_id;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
630 do
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
631 local data = assert(archive:find("user", {}));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
632 local count = 0;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
633 for id, item, when in data do --luacheck: ignore 213/item 213/when
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
634 count = count + 1;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
635 if count == 2 then
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
636 delete_id = id;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
637 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
638 assert.truthy(id);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
639 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
640 assert.equal(#test_data, count);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
641 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
642
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
643 assert(archive:delete("user", { key = delete_id }));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
644
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
645 do
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
646 local data = assert(archive:find("user", {}));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
647 local count = 0;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
648 for id, item, when in data do --luacheck: ignore 213/item 213/when
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
649 count = count + 1;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
650 assert.truthy(id);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
651 assert.not_equal(delete_id, id);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
652 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
653 assert.equal(#test_data-1, count);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
654 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
655 end);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
656
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
657 it("can be purged", function ()
10541
6c6ff4509082 tests: Silence [luacheck] warnings
Kim Alvefur <zash@zash.se>
parents: 9691
diff changeset
658 -- luacheck: ignore 211/err
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
659 local ok, err = archive:delete("user");
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
660 assert.truthy(ok);
9467
2098794ac866 storagemanager tests: Add some additional checks
Matthew Wild <mwild1@gmail.com>
parents: 9466
diff changeset
661 local data, err = archive:find("user", {
2098794ac866 storagemanager tests: Add some additional checks
Matthew Wild <mwild1@gmail.com>
parents: 9466
diff changeset
662 with = "contact@example.com";
2098794ac866 storagemanager tests: Add some additional checks
Matthew Wild <mwild1@gmail.com>
parents: 9466
diff changeset
663 });
13133
3692265becb7 storagemanager tests: Reorder test data in chronological order
Kim Alvefur <zash@zash.se>
parents: 12956
diff changeset
664 assert.truthy(data, err);
9467
2098794ac866 storagemanager tests: Add some additional checks
Matthew Wild <mwild1@gmail.com>
parents: 9466
diff changeset
665 local count = 0;
2098794ac866 storagemanager tests: Add some additional checks
Matthew Wild <mwild1@gmail.com>
parents: 9466
diff changeset
666 for id, item, when in data do -- luacheck: ignore id item when
2098794ac866 storagemanager tests: Add some additional checks
Matthew Wild <mwild1@gmail.com>
parents: 9466
diff changeset
667 count = count + 1;
2098794ac866 storagemanager tests: Add some additional checks
Matthew Wild <mwild1@gmail.com>
parents: 9466
diff changeset
668 end
2098794ac866 storagemanager tests: Add some additional checks
Matthew Wild <mwild1@gmail.com>
parents: 9466
diff changeset
669 assert.equal(0, count);
9466
b70ce39d366f storagemanager tests: Add initial basic tests for archive stores
Matthew Wild <mwild1@gmail.com>
parents: 9452
diff changeset
670 end);
9471
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
671
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
672 it("can truncate the oldest items", function ()
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
673 local username = "user-truncate";
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
674 for i = 1, 10 do
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
675 assert(archive:append(username, nil, test_stanza, i, "contact@example.com"));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
676 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
677 assert(archive:delete(username, { truncate = 3 }));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
678
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
679 do
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
680 local data = assert(archive:find(username, {}));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
681 local count = 0;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
682 for id, item, when in data do --luacheck: ignore 213/when
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
683 count = count + 1;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
684 assert.truthy(id);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
685 assert(st.is_stanza(item));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
686 assert(when > 7, ("%d > 7"):format(when));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
687 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
688 assert.equal(3, count);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
689 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
690 end);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
691
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
692 it("overwrites existing keys with new data", function ()
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
693 local prefix = ("a"):rep(50);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
694 local username = "user-overwrite";
11739
e0d0680e04cc core.storagemanager: Respect archive ids issued by storage drivers in tests
Kim Alvefur <zash@zash.se>
parents: 11424
diff changeset
695 local a1 = assert(archive:append(username, prefix.."-1", test_stanza, test_time, "contact@example.com"));
e0d0680e04cc core.storagemanager: Respect archive ids issued by storage drivers in tests
Kim Alvefur <zash@zash.se>
parents: 11424
diff changeset
696 local a2 = assert(archive:append(username, prefix.."-2", test_stanza, test_time, "contact@example.com"));
e0d0680e04cc core.storagemanager: Respect archive ids issued by storage drivers in tests
Kim Alvefur <zash@zash.se>
parents: 11424
diff changeset
697 local ids = { a1, a2, };
9471
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
698
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
699 do
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
700 local data = assert(archive:find(username, {}));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
701 local count = 0;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
702 for id, item, when in data do --luacheck: ignore 213/when
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
703 count = count + 1;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
704 assert.truthy(id);
11739
e0d0680e04cc core.storagemanager: Respect archive ids issued by storage drivers in tests
Kim Alvefur <zash@zash.se>
parents: 11424
diff changeset
705 assert.equals(ids[count], id);
9471
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
706 assert(st.is_stanza(item));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
707 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
708 assert.equal(2, count);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
709 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
710
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
711 local new_stanza = st.clone(test_stanza);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
712 new_stanza.attr.foo = "bar";
11739
e0d0680e04cc core.storagemanager: Respect archive ids issued by storage drivers in tests
Kim Alvefur <zash@zash.se>
parents: 11424
diff changeset
713 assert(archive:append(username, a2, new_stanza, test_time+1, "contact2@example.com"));
9471
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
714
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
715 do
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
716 local data = assert(archive:find(username, {}));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
717 local count = 0;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
718 for id, item, when in data do
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
719 count = count + 1;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
720 assert.truthy(id);
11739
e0d0680e04cc core.storagemanager: Respect archive ids issued by storage drivers in tests
Kim Alvefur <zash@zash.se>
parents: 11424
diff changeset
721 assert.equals(ids[count], id);
9471
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
722 assert(st.is_stanza(item));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
723 if count == 2 then
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
724 assert.equals(test_time+1, when);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
725 assert.equals("bar", item.attr.foo);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
726 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
727 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
728 assert.equal(2, count);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
729 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
730 end);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
731
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
732 it("can contain multiple long unique keys #issue1073", function ()
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
733 local prefix = ("a"):rep(50);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
734 assert(archive:append("user-issue1073", prefix.."-1", test_stanza, test_time, "contact@example.com"));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
735 assert(archive:append("user-issue1073", prefix.."-2", test_stanza, test_time, "contact@example.com"));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
736
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
737 local data = assert(archive:find("user-issue1073", {}));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
738 local count = 0;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
739 for id, item, when in data do --luacheck: ignore 213/when
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
740 count = count + 1;
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
741 assert.truthy(id);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
742 assert(st.is_stanza(item));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
743 end
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
744 assert.equal(2, count);
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
745 assert(archive:delete("user-issue1073"));
6798fcd25e9c storagemanager tests: Add many more archive tests, including (failing) cases for #1200 and #1073
Matthew Wild <mwild1@gmail.com>
parents: 9470
diff changeset
746 end);
10837
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
747
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
748 it("can be treated as a map store", function ()
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
749 assert.falsy(archive:get("mapuser", "no-such-id"));
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
750 assert.falsy(archive:set("mapuser", "no-such-id", test_stanza));
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
751
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
752 local id = archive:append("mapuser", nil, test_stanza, test_time, "contact@example.com");
10842
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
753 do
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
754 local stanza_roundtrip, when, with = archive:get("mapuser", id);
11354
10fba62332c5 mod_storage_sql: Implement map-like API for archives
Kim Alvefur <zash@zash.se>
parents: 11353
diff changeset
755 assert.same(tostring(test_stanza), tostring(stanza_roundtrip), "same stanza is returned");
10842
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
756 assert.equal(test_time, when, "same 'when' is returned");
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
757 assert.equal("contact@example.com", with, "same 'with' is returned");
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
758 end
10837
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
759
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
760 local replacement_stanza = st.stanza("test", { xmlns = "urn:example:foo" })
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
761 :tag("bar"):up()
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
762 :reset();
10842
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
763 assert(archive:set("mapuser", id, replacement_stanza, test_time+1));
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
764
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
765 do
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
766 local replaced, when, with = archive:get("mapuser", id);
11354
10fba62332c5 mod_storage_sql: Implement map-like API for archives
Kim Alvefur <zash@zash.se>
parents: 11353
diff changeset
767 assert.same(tostring(replacement_stanza), tostring(replaced), "replaced stanza is returned");
10842
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
768 assert.equal(test_time+1, when, "modified 'when' is returned");
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
769 assert.equal("contact@example.com", with, "original 'with' is returned");
5a6ba2f38e2b mod_storage_internal: Fix keeping old timestamp in archive map API
Kim Alvefur <zash@zash.se>
parents: 10837
diff changeset
770 end
10837
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
771 end);
f23363380599 mod_storage_internal: Implement key-value API
Kim Alvefur <zash@zash.se>
parents: 10836
diff changeset
772
12598
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
773 it("the summary api works", function()
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
774 assert.truthy(archive:delete("summary-user"));
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
775 local first_sid = archive:append("summary-user", nil, test_stanza, test_time, "contact@example.com");
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
776 local second_sid = archive:append("summary-user", nil, test_stanza, test_time+1, "contact@example.com");
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
777 assert.truthy(first_sid and second_sid, "preparations failed")
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
778 ---
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
779
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
780 local user_summary, err = archive:summary("summary-user");
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
781 assert.is_table(user_summary, err);
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
782 assert.same({ ["contact@example.com"] = 2 }, user_summary.counts, "summary.counts matches");
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
783 assert.same({ ["contact@example.com"] = test_time }, user_summary.earliest, "summary.earliest matches");
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
784 assert.same({ ["contact@example.com"] = test_time+1 }, user_summary.latest, "summary.latest matches");
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
785 if user_summary.body then
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
786 assert.same({ ["contact@example.com"] = test_stanza:get_child_text("body") }, user_summary.body, "summary.body matches");
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
787 end
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
788 end);
a2624315d30e storage tests: Add test for the archive:summary API
Kim Alvefur <zash@zash.se>
parents: 11739
diff changeset
789
9389
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
790 end);
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
791 end);
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
792 end
9ae575efbb1f Add storage tests (currently only internal and sqlite)
Matthew Wild <mwild1@gmail.com>
parents:
diff changeset
793 end);