lukechilds
/
keyv-1
mirror of https://github.com/lukechilds/keyv-1.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Split tests up into seperate files 

Allow tests to be imported seperately or use helper to run them all
emp
Luke Childs 7 years ago
committed by Jytesh
parent
3a445e36af
commit
7d8f088a83
3 changed files with 167 additions and 141 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 99
      packages/keyv-test-suite/src/api.js
  2. 151
      packages/keyv-test-suite/src/index.js
  3. 58
      packages/keyv-test-suite/src/values.js

99
packages/keyv-test-suite/src/api.js
View File

@ -0,0 +1,99 @@
import delay from 'delay';
const keyvApiTests = (test, Keyv, store) => {
test.beforeEach(async () => {
const keyv = new Keyv({ store });
await keyv.clear();
});
test.serial('.set(key, value) returns a Promise', t => {
const keyv = new Keyv({ store });
t.true(keyv.set('foo', 'bar') instanceof Promise);
});
test.serial('.set(key, value) resolves to true', async t => {
const keyv = new Keyv({ store });
t.is(await keyv.set('foo', 'bar'), true);
});
test.serial('.set(key, value) sets a value', async t => {
const keyv = new Keyv({ 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 keyv = new Keyv({ store });
await keyv.set('foo', 'bar', 100);
t.is(await keyv.get('foo'), 'bar');
await delay(110);
t.is(await keyv.get('foo'), undefined);
});
test.serial('.get(key) returns a Promise', t => {
const keyv = new Keyv({ store });
t.true(keyv.get('foo') instanceof Promise);
});
test.serial('.get(key) resolves to value', async t => {
const keyv = new Keyv({ 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 });
t.is(await keyv.get('foo'), undefined);
});
test.serial('.delete(key) returns a Promise', t => {
const keyv = new Keyv({ store });
t.true(keyv.delete('foo') instanceof Promise);
});
test.serial('.delete(key) resolves to true', async t => {
const keyv = new Keyv({ 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 });
t.is(await keyv.delete('foo'), false);
});
test.serial('.delete(key) deletes a key', async t => {
const keyv = new Keyv({ 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', t => {
const keyv = new Keyv({ store });
t.true(keyv.clear() instanceof Promise);
});
test.serial('.clear() resolves to undefiend', async t => {
const keyv = new Keyv({ 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 });
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.after.always(async () => {
const keyv = new Keyv({ store });
await keyv.clear();
});
};
export default keyvApiTests;

151
packages/keyv-test-suite/src/index.js
View File

@ -1,144 +1,13 @@
import delay from 'delay'; import keyvApiTests from './api';
import keyvValueTests from './values';
const keyvApiTests = (test, Keyv, store) => { const keyvTestSuite = (test, Keyv, store) => {
test.beforeEach(async () => { keyvApiTests(test, Keyv, store);
const keyv = new Keyv({ store }); keyvValueTests(test, Keyv, store);
await keyv.clear();
});
test.serial('.set(key, value) returns a Promise', t => {
const keyv = new Keyv({ store });
t.true(keyv.set('foo', 'bar') instanceof Promise);
});
test.serial('.set(key, value) resolves to true', async t => {
const keyv = new Keyv({ store });
t.is(await keyv.set('foo', 'bar'), true);
});
test.serial('.set(key, value) sets a value', async t => {
const keyv = new Keyv({ 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 keyv = new Keyv({ store });
await keyv.set('foo', 'bar', 100);
t.is(await keyv.get('foo'), 'bar');
await delay(110);
t.is(await keyv.get('foo'), undefined);
});
test.serial('.get(key) returns a Promise', t => {
const keyv = new Keyv({ store });
t.true(keyv.get('foo') instanceof Promise);
});
test.serial('.get(key) resolves to value', async t => {
const keyv = new Keyv({ 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 });
t.is(await keyv.get('foo'), undefined);
});
test.serial('.delete(key) returns a Promise', t => {
const keyv = new Keyv({ store });
t.true(keyv.delete('foo') instanceof Promise);
});
test.serial('.delete(key) resolves to true', async t => {
const keyv = new Keyv({ 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 });
t.is(await keyv.delete('foo'), false);
});
test.serial('.delete(key) deletes a key', async t => {
const keyv = new Keyv({ 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', t => {
const keyv = new Keyv({ store });
t.true(keyv.clear() instanceof Promise);
});
test.serial('.clear() resolves to undefiend', async t => {
const keyv = new Keyv({ 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 });
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('value can be false', async t => {
const keyv = new Keyv({ store });
await keyv.set('foo', false);
t.is(await keyv.get('foo'), false);
});
test.serial('value can be null', async t => {
const keyv = new Keyv({ store });
await keyv.set('foo', null);
t.is(await keyv.get('foo'), null);
});
test.serial('value can be undefined', async t => {
const keyv = new Keyv({ store });
await keyv.set('foo', undefined);
t.is(await keyv.get('foo'), undefined);
});
test.serial('value can be a number', async t => {
const keyv = new Keyv({ store });
await keyv.set('foo', 0);
t.is(await keyv.get('foo'), 0);
});
test.serial('value can be an object', async t => {
const keyv = new Keyv({ store });
const value = { fizz: 'buzz' };
await keyv.set('foo', value);
t.deepEqual(await keyv.get('foo'), value);
});
test.serial('value can be a buffer', async t => {
const keyv = new Keyv({ store });
const buf = Buffer.from('bar');
await keyv.set('foo', buf);
t.true(buf.equals(await keyv.get('foo')));
});
test.serial('value can be an object containing a buffer', async t => {
const keyv = new Keyv({ store });
const value = { buff: Buffer.from('buzz') };
await keyv.set('foo', value);
t.deepEqual(await keyv.get('foo'), value);
});
test.after.always(async () => {
const keyv = new Keyv({ store });
await keyv.clear();
});
}; };
export default keyvApiTests; export {
keyvApiTests,
keyvValueTests
};
export default keyvTestSuite;

58
packages/keyv-test-suite/src/values.js
View File

@ -0,0 +1,58 @@
const keyvValueTests = (test, Keyv, store) => {
test.beforeEach(async () => {
const keyv = new Keyv({ store });
await keyv.clear();
});
test.serial('value can be false', async t => {
const keyv = new Keyv({ store });
await keyv.set('foo', false);
t.is(await keyv.get('foo'), false);
});
test.serial('value can be null', async t => {
const keyv = new Keyv({ store });
await keyv.set('foo', null);
t.is(await keyv.get('foo'), null);
});
test.serial('value can be undefined', async t => {
const keyv = new Keyv({ store });
await keyv.set('foo', undefined);
t.is(await keyv.get('foo'), undefined);
});
test.serial('value can be a number', async t => {
const keyv = new Keyv({ store });
await keyv.set('foo', 0);
t.is(await keyv.get('foo'), 0);
});
test.serial('value can be an object', async t => {
const keyv = new Keyv({ store });
const value = { fizz: 'buzz' };
await keyv.set('foo', value);
t.deepEqual(await keyv.get('foo'), value);
});
test.serial('value can be a buffer', async t => {
const keyv = new Keyv({ store });
const buf = Buffer.from('bar');
await keyv.set('foo', buf);
t.true(buf.equals(await keyv.get('foo')));
});
test.serial('value can be an object containing a buffer', async t => {
const keyv = new Keyv({ store });
const value = { buff: Buffer.from('buzz') };
await keyv.set('foo', value);
t.deepEqual(await keyv.get('foo'), value);
});
test.after.always(async () => {
const keyv = new Keyv({ store });
await keyv.clear();
});
};
export default keyvValueTests;
Write Preview
Loading…
Cancel
Save