test: add a test for set db.exists (#13809)

* test: add a test for set db.exists

* delete empty sets

* test: psql

src/database/mongo/sets.js

@@ -100,11 +100,17 @@ module.exports = function (module) {
 
 		value = value.map(v => helpers.valueToString(v));
 
-		await module.client.collection('objects').updateMany({
+		const coll = module.client.collection('objects');
+		await coll.updateMany({
 			_key: Array.isArray(key) ? { $in: key } : key,
 		}, {
 			$pullAll: { members: value },
 		});
+
+		await coll.deleteMany({
+			_key: Array.isArray(key) ? { $in: key } : key,
+			members: { $size: 0 },
+		});
 	};
 
 	module.setsRemove = async function (keys, value) {
@@ -113,11 +119,17 @@ module.exports = function (module) {
 		}
 		value = helpers.valueToString(value);
 
-		await module.client.collection('objects').updateMany({
+		const coll = module.client.collection('objects');
+		await coll.updateMany({
 			_key: { $in: keys },
 		}, {
 			$pull: { members: value },
 		});
+
+		await coll.deleteMany({
+			_key: { $in: keys },
+			members: { $size: 0 },
+		});
 	};
 
 	module.isSetMember = async function (key, value) {

src/database/postgres/main.js

@@ -28,6 +28,11 @@ module.exports = function (module) {
 			return members.map(member => member.length > 0);
 		}
 
+		async function checkIfSetsExist(keys) {
+			const members = await Promise.all(keys.map(module.getSetMembers));
+			return members.map(member => member.length > 0);
+		}
+
 		async function checkIfKeysExist(keys) {
 			const res = await module.pool.query({
 				name: 'existsArray',
@@ -44,13 +49,16 @@ module.exports = function (module) {
 		if (isArray) {
 			const types = await Promise.all(key.map(module.type));
 			const zsetKeys = key.filter((_key, i) => types[i] === 'zset');
-			const otherKeys = key.filter((_key, i) => types[i] !== 'zset');
+			const setKeys = key.filter((_key, i) => types[i] === 'set');
-			const [zsetExits, otherExists] = await Promise.all([
+			const otherKeys = key.filter((_key, i) => types[i] !== 'zset' && types[i] !== 'set');
+			const [zsetExits, setExists, otherExists] = await Promise.all([
 				checkIfzSetsExist(zsetKeys),
+				checkIfSetsExist(setKeys),
 				checkIfKeysExist(otherKeys),
 			]);
 			const existsMap = Object.create(null);
 			zsetKeys.forEach((k, i) => { existsMap[k] = zsetExits[i]; });
+			setKeys.forEach((k, i) => { existsMap[k] = setExists[i]; });
 			otherKeys.forEach((k, i) => { existsMap[k] = otherExists[i]; });
 			return key.map(k => existsMap[k]);
 		}
@@ -58,6 +66,9 @@ module.exports = function (module) {
 		if (type === 'zset') {
 			const members = await module.getSortedSetRange(key, 0, 0);
 			return members.length > 0;
+		} else if (type === 'set') {
+			const members = await module.getSetMembers(key);
+			return members.length > 0;
 		}
 		const res = await module.pool.query({
 			name: 'exists',

test/database/sets.js

@@ -238,57 +238,42 @@ describe('Set methods', () => {
 	});
 
 	describe('setRemove()', () => {
-		before((done) => {
+		it('should remove an element from set', async () => {
-			db.setAdd('testSet6', [1, 2], done);
+			await db.setAdd('testSet6', [1, 2]);
+			await db.setRemove('testSet6', '2');
+
+			const isMember = await db.isSetMember('testSet6', '2');
+			assert.equal(isMember, false);
 		});
 
-		it('should remove a element from set', (done) => {
+		it('should remove multiple elements from set', async () => {
-			db.setRemove('testSet6', '2', function (err) {
+			await db.setAdd('multiRemoveSet', [1, 2, 3, 4, 5]);
-				assert.equal(err, null);
+			await db.setRemove('multiRemoveSet', [1, 3, 5]);
-				assert.equal(arguments.length, 1);
 
-				db.isSetMember('testSet6', '2', (err, isMember) => {
+			const members = await db.getSetMembers('multiRemoveSet');
-					assert.equal(err, null);
+			assert(members.includes('2'));
-					assert.equal(isMember, false);
+			assert(members.includes('4'));
-					done();
-				});
-			});
 		});
 
-		it('should remove multiple elements from set', (done) => {
+		it('should remove multiple values from multiple keys', async () => {
-			db.setAdd('multiRemoveSet', [1, 2, 3, 4, 5], (err) => {
+			await db.setAdd('multiSetTest1', ['one', 'two', 'three', 'four']);
-				assert.ifError(err);
+			await db.setAdd('multiSetTest2', ['three', 'four', 'five', 'six']);
-				db.setRemove('multiRemoveSet', [1, 3, 5], (err) => {
+			await db.setRemove(['multiSetTest1', 'multiSetTest2'], ['three', 'four', 'five', 'doesnt exist']);
-					assert.ifError(err);
+
-					db.getSetMembers('multiRemoveSet', (err, members) => {
+			const members = await db.getSetsMembers(['multiSetTest1', 'multiSetTest2']);
-						assert.ifError(err);
+			assert.equal(members[0].length, 2);
-						assert(members.includes('2'));
+			assert.equal(members[1].length, 1);
-						assert(members.includes('4'));
+			assert(members[0].includes('one'));
-						done();
+			assert(members[0].includes('two'));
-					});
+			assert(members[1].includes('six'));
-				});
-			});
 		});
 
-		it('should remove multiple values from multiple keys', (done) => {
+		it('should remove set if all elements are removed', async () => {
-			db.setAdd('multiSetTest1', ['one', 'two', 'three', 'four'], (err) => {
+			await db.setAdd('toBeDeletedSet', ['a', 'b']);
-				assert.ifError(err);
+			await db.setRemove('toBeDeletedSet', ['a', 'b']);
-				db.setAdd('multiSetTest2', ['three', 'four', 'five', 'six'], (err) => {
+
-					assert.ifError(err);
+			const exists = await db.exists('toBeDeletedSet');
-					db.setRemove(['multiSetTest1', 'multiSetTest2'], ['three', 'four', 'five', 'doesnt exist'], (err) => {
+			assert.equal(exists, false);
-						assert.ifError(err);
-						db.getSetsMembers(['multiSetTest1', 'multiSetTest2'], (err, members) => {
-							assert.ifError(err);
-							assert.equal(members[0].length, 2);
-							assert.equal(members[1].length, 1);
-							assert(members[0].includes('one'));
-							assert(members[0].includes('two'));
-							assert(members[1].includes('six'));
-							done();
-						});
-					});
-				});
-			});
 		});
 	});