keyv-api-tests/dist/index.js

'use strict';

Object.defineProperty(exports, "__esModule", {
	value: true
});

var _delay = require('delay');

var _delay2 = _interopRequireDefault(_delay);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

const keyvApiTests = (test, Keyv, store) => {
	test.beforeEach(_asyncToGenerator(function* () {
		const keyv = new Keyv({ store: store });
		yield 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 value', (() => {
		var _ref2 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			t.is((yield keyv.set('foo', 'bar')), 'bar');
		});

		return function (_x) {
			return _ref2.apply(this, arguments);
		};
	})());

	test.serial('.set(key, value) sets a value', (() => {
		var _ref3 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			t.is((yield keyv.set('foo', 'bar')), 'bar');
			t.is((yield keyv.get('foo')), 'bar');
		});

		return function (_x2) {
			return _ref3.apply(this, arguments);
		};
	})());

	test.serial('.set(key, value, ttl) sets a value that expires', (() => {
		var _ref4 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			t.is((yield keyv.set('foo', 'bar', 100)), 'bar');
			t.is((yield keyv.get('foo')), 'bar');
			yield (0, _delay2.default)(110);
			t.is((yield keyv.get('foo')), undefined);
		});

		return function (_x3) {
			return _ref4.apply(this, arguments);
		};
	})());

	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', (() => {
		var _ref5 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			yield keyv.set('foo', 'bar');
			t.is((yield keyv.get('foo')), 'bar');
		});

		return function (_x4) {
			return _ref5.apply(this, arguments);
		};
	})());

	test.serial('.get(key) with nonexistent key resolves to undefined', (() => {
		var _ref6 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			t.is((yield keyv.get('foo')), undefined);
		});

		return function (_x5) {
			return _ref6.apply(this, arguments);
		};
	})());

	test.serial('.get(key) with falsey key resolves to value', (() => {
		var _ref7 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			yield keyv.set('foo', false);
			t.is((yield keyv.get('foo')), false);
		});

		return function (_x6) {
			return _ref7.apply(this, arguments);
		};
	})());

	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', (() => {
		var _ref8 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			yield keyv.set('foo', 'bar');
			t.is((yield keyv.delete('foo')), true);
		});

		return function (_x7) {
			return _ref8.apply(this, arguments);
		};
	})());

	test.serial('.delete(key) with nonexistent key resolves to false', (() => {
		var _ref9 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			t.is((yield keyv.delete('foo')), false);
		});

		return function (_x8) {
			return _ref9.apply(this, arguments);
		};
	})());

	test.serial('.delete(key) deletes a key', (() => {
		var _ref10 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			yield keyv.set('foo', 'bar');
			t.is((yield keyv.delete('foo')), true);
			t.is((yield keyv.get('foo')), undefined);
		});

		return function (_x9) {
			return _ref10.apply(this, arguments);
		};
	})());

	test.serial('.clear() returns a Promise', t => {
		const keyv = new Keyv({ store: store });
		t.true(keyv.clear() instanceof Promise);
	});

	test.serial('.clear() resolves to undefiend', (() => {
		var _ref11 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			t.is((yield keyv.clear()), undefined);
			yield keyv.set('foo', 'bar');
			t.is((yield keyv.clear()), undefined);
		});

		return function (_x10) {
			return _ref11.apply(this, arguments);
		};
	})());

	test.serial('.clear() deletes all key/value pairs', (() => {
		var _ref12 = _asyncToGenerator(function* (t) {
			const keyv = new Keyv({ store: store });
			yield keyv.set('foo', 'bar');
			yield keyv.set('fizz', 'buzz');
			yield keyv.clear();
			t.is((yield keyv.get('foo')), undefined);
			t.is((yield keyv.get('fizz')), undefined);
		});

		return function (_x11) {
			return _ref12.apply(this, arguments);
		};
	})());

	test.after.always(_asyncToGenerator(function* () {
		const keyv = new Keyv({ store: store });
		yield keyv.clear();
	}));
};

exports.default = keyvApiTests;