/
api.js
126 lines (105 loc) · 3.64 KB
/
api.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
const tk = require('timekeeper');
const delay = require('delay');
const keyvApiTests = (test, Keyv, store) => {
test.beforeEach(async () => {
const keyv = new Keyv({ store: store() });
await keyv.clear();
});
test.serial('.set(key, value) returns a Promise', t => {
const keyv = new Keyv({ store: store() });
t.true(keyv.set('foo', 'bar') instanceof Promise);
});
test.serial('.set(key, value) resolves to true', async t => {
const keyv = new Keyv({ store: store() });
t.is(await keyv.set('foo', 'bar'), true);
});
test.serial('.set(key, value) sets a value', async t => {
const keyv = new Keyv({ store: store() });
await keyv.set('foo', 'bar');
t.is(await keyv.get('foo'), 'bar');
});
test.serial('.set(key, value, ttl) sets a value that expires', async t => {
const ttl = 1000;
const keyv = new Keyv({ store: store() });
await keyv.set('foo', 'bar', ttl);
t.is(await keyv.get('foo'), 'bar');
if (keyv.store.ttlSupport === true) {
await delay(ttl + 1);
} else {
tk.freeze(Date.now() + ttl + 1);
}
t.is(await keyv.get('foo'), undefined);
tk.reset();
});
test.serial('.get(key) returns a Promise', t => {
const keyv = new Keyv({ store: store() });
t.true(keyv.get('foo') instanceof Promise);
});
test.serial('.get(key) resolves to value', async t => {
const keyv = new Keyv({ store: store() });
await keyv.set('foo', 'bar');
t.is(await keyv.get('foo'), 'bar');
});
test.serial('.get(key) with nonexistent key resolves to undefined', async t => {
const keyv = new Keyv({ store: store() });
t.is(await keyv.get('foo'), undefined);
});
test.serial('.delete(key) returns a Promise', t => {
const keyv = new Keyv({ store: store() });
t.true(keyv.delete('foo') instanceof Promise);
});
test.serial('.delete(key) resolves to true', async t => {
const keyv = new Keyv({ store: store() });
await keyv.set('foo', 'bar');
t.is(await keyv.delete('foo'), true);
});
test.serial('.delete(key) with nonexistent key resolves to false', async t => {
const keyv = new Keyv({ store: store() });
t.is(await keyv.delete(), false);
t.is(await keyv.delete('foo'), false);
});
test.serial('.delete(key) deletes a key', async t => {
const keyv = new Keyv({ store: store() });
await keyv.set('foo', 'bar');
t.is(await keyv.delete('foo'), true);
t.is(await keyv.get('foo'), undefined);
});
test.serial('.clear() returns a Promise', async t => {
const keyv = new Keyv({ store: store() });
const returnValue = keyv.clear();
t.true(returnValue instanceof Promise);
await returnValue;
});
test.serial('.clear() resolves to undefined', async t => {
const keyv = new Keyv({ store: store() });
t.is(await keyv.clear(), undefined);
await keyv.set('foo', 'bar');
t.is(await keyv.clear(), undefined);
});
test.serial('.clear() deletes all key/value pairs', async t => {
const keyv = new Keyv({ store: store() });
await keyv.set('foo', 'bar');
await keyv.set('fizz', 'buzz');
await keyv.clear();
t.is(await keyv.get('foo'), undefined);
t.is(await keyv.get('fizz'), undefined);
});
test.serial('.has(key) returns a Promise', t => {
const keyv = new Keyv({ store: store() });
t.true(keyv.has('foo') instanceof Promise);
});
test.serial('.has(key) resolves to true', async t => {
const keyv = new Keyv({ store: store() });
await keyv.set('foo', 'bar');
t.is(await keyv.has('foo'), true);
});
test.serial('.has(key) with nonexistent key resolves to false', async t => {
const keyv = new Keyv({ store: store() });
t.is(await keyv.has('foo'), false);
});
test.after.always(async () => {
const keyv = new Keyv({ store: store() });
await keyv.clear();
});
};
module.exports = keyvApiTests;