window.kvTests = [ testSetKeyWithValue = async function() { try { const result = await puter.kv.set('testKey', 'testValue'); assert(result === true, "Failed to set key with value"); pass("testSetKeyWithValue passed"); } catch (error) { fail("testSetKeyWithValue failed:", error); } }, testUpdateKey = async function() { try { await puter.kv.set('updateKey', 'initialValue'); const result = await puter.kv.set('updateKey', 'updatedValue'); assert(result === true, "Failed to update existing key"); pass("testUpdateKey passed"); } catch (error) { fail("testUpdateKey failed:", error); } }, testKeySizeLimit = async function() { try { const largeKey = 'a'.repeat(1025); // 1 KB + 1 byte await puter.kv.set(largeKey, 'value'); fail("testKeySizeLimit failed: No error thrown for large key"); } catch (error) { pass("testKeySizeLimit passed:", error.message); } }, testInvalidParameters = async function() { try { await puter.kv.set(undefined, 'value'); fail("testInvalidParameters failed: No error thrown for undefined key"); } catch (error) { pass("testInvalidParameters passed:", error.message); } }, // testEmptyKey should fail testEmptyKey = async function() { try { await puter.kv.set('', 'value'); fail("testEmptyKey failed: No error thrown for empty key"); } catch (error) { pass("testEmptyKey passed:", error.message); } }, testSetNullValue = async function() { try { const result = await puter.kv.set('nullValueKey', null); assert(result === true, "Failed to set null value"); pass("testSetNullValue passed"); } catch (error) { fail("testSetNullValue failed:", error); } }, testSetObjectValue = async function() { try { const result = await puter.kv.set('objectKey', { a: 1 }); assert(result === true, "Failed to set object as value"); pass("testSetObjectValue passed"); } catch (error) { fail("testSetObjectValue failed:", error); } }, testSetKeyWithSpecialCharacters = async function() { try { const result = await puter.kv.set('special@Key#', 'value'); assert(result === true, "Failed to set key with special characters"); pass("testSetKeyWithSpecialCharacters passed"); } catch (error) { fail("testSetKeyWithSpecialCharacters failed:", error); } }, testSetLargeValue = async function() { try { const largeValue = 'a'.repeat(10000); // 10 KB const result = await puter.kv.set('largeValueKey', largeValue); assert(result === true, "Failed to set large value"); pass("testSetLargeValue passed"); } catch (error) { fail("testSetLargeValue failed:", error); } }, testSetBooleanValue = async function() { try { const result = await puter.kv.set('booleanKey', true); assert(result === true, "Failed to set boolean value"); pass("testSetBooleanValue passed"); } catch (error) { fail("testSetBooleanValue failed:", error); } }, testSetNumericKey = async function() { try { const result = await puter.kv.set(123, 'value'); assert(result === true, "Failed to set numeric key"); pass("testSetNumericKey passed"); } catch (error) { fail("testSetNumericKey failed:", error); } }, testSetConcurrentKeys = async function() { try { const promises = [puter.kv.set('key1', 'value1'), puter.kv.set('key2', 'value2')]; const results = await Promise.all(promises); assert(results.every(result => result === true), "Failed to set concurrent keys"); pass("testSetConcurrentKeys passed"); } catch (error) { fail("testSetConcurrentKeys failed:", error); } }, testSetValueAndRetrieve = async function() { try { await puter.kv.set('retrieveKey', 'testValue'); const value = await puter.kv.get('retrieveKey'); assert(value === 'testValue', "Failed to retrieve correct value"); pass("testSetValueAndRetrieve passed"); } catch (error) { fail("testSetValueAndRetrieve failed:", error); } }, testUpdateValueAndRetrieve = async function() { try { await puter.kv.set('updateKey', 'initialValue'); await puter.kv.set('updateKey', 'updatedValue'); const value = await puter.kv.get('updateKey'); assert(value === 'updatedValue', "Failed to retrieve updated value"); pass("testUpdateValueAndRetrieve passed"); } catch (error) { fail("testUpdateValueAndRetrieve failed:", error); } }, testSetNumericValueAndRetrieve = async function() { try { await puter.kv.set('numericKey', 123); const value = await puter.kv.get('numericKey'); assert(value === 123, "Failed to retrieve numeric value"); pass("testSetNumericValueAndRetrieve passed"); } catch (error) { fail("testSetNumericValueAndRetrieve failed:", error); } }, testSetBooleanValueAndRetrieve = async function() { try { await puter.kv.set('booleanKey', true); const value = await puter.kv.get('booleanKey'); assert(value === true, "Failed to retrieve boolean value"); pass("testSetBooleanValueAndRetrieve passed"); } catch (error) { fail("testSetBooleanValueAndRetrieve failed:", error); } }, testSetAndDeleteKey = async function() { try { await puter.kv.set('deleteKey', 'value'); const result = await puter.kv.del('deleteKey'); assert(result === true, "Failed to delete key"); pass("testSetAndDeleteKey passed"); } catch (error) { fail("testSetAndDeleteKey failed:", error); } }, // if key does not exist, get() should return null testGetNonexistentKey = async function() { try { const value = await puter.kv.get('nonexistentKey_102mk'); assert(value === null, "Failed to return `null` for nonexistent key"); pass("testGetNonexistentKey passed"); } catch (error) { fail("testGetNonexistentKey failed:", error); } }, // string key and object value testSetObjectValue = async function() { try { const result = await puter.kv.set('objectKey', { a: 1 }); assert(result === true, "Failed to set object as value"); const value = await puter.kv.get('objectKey'); assert(value.a === 1, "Failed to retrieve object value"); pass("testSetObjectValue passed"); } catch (error) { fail("testSetObjectValue failed:", error); } }, // string key and array value testSetArrayValue = async function() { try { const result = await puter.kv.set('arrayKey', [1, 2, 3]); assert(result === true, "Failed to set array as value"); const value = await puter.kv.get('arrayKey'); assert(value[0] === 1, "Failed to retrieve array value"); pass("testSetArrayValue passed"); } catch (error) { fail("testSetArrayValue failed:", error); } }, testSetKeyWithSpecialCharactersAndRetrieve = async function() { try { await puter.kv.set('special@Key#', 'value'); const value = await puter.kv.get('special@Key#'); assert(value === 'value', "Failed to retrieve value for key with special characters"); pass("testSetKeyWithSpecialCharactersAndRetrieve passed"); } catch (error) { fail("testSetKeyWithSpecialCharactersAndRetrieve failed:", error); } }, testConcurrentSetOperations = async function() { try { const promises = [puter.kv.set('key1', 'value1'), puter.kv.set('key2', 'value2')]; const results = await Promise.all(promises); assert(results.every(result => result === true), "Failed to set concurrent keys"); pass("testConcurrentSetOperations passed"); } catch (error) { fail("testConcurrentSetOperations failed:", error); } }, //test flush: create a bunch of keys, flush, then check if they exist testFlush = async function() { try { const keys = []; for(let i = 0; i < 10; i++){ keys.push('key' + i); } await Promise.all(keys.map(key => puter.kv.set(key, 'value'))); await puter.kv.flush(); const results = await Promise.all(keys.map(key => puter.kv.get(key))); assert(results.every(result => result === null), "Failed to flush keys"); pass("testFlush passed"); } catch (error) { fail("testFlush failed:", error); } }, // incr testIncr = async function() { try { const result = await puter.kv.incr('incrKey'); assert(result === 1, "Failed to increment key"); pass("testIncr passed"); } catch (error) { fail("testIncr failed:", error); } }, // decr testDecr = async function() { try { const result = await puter.kv.decr('decrKey'); assert(result === -1, "Failed to decrement key"); pass("testDecr passed"); } catch (error) { fail("testDecr failed:", error); } }, // incr existing key testIncrExistingKey = async function() { try { await puter.kv.set('incrKey', 1); const result = await puter.kv.incr('incrKey'); assert(result === 2, "Failed to increment existing key"); pass("testIncrExistingKey passed"); } catch (error) { fail("testIncrExistingKey failed:", error); } }, // decr existing key testIncrExistingKey = async function() { try { await puter.kv.set('decrKey', 2); const result = await puter.kv.decr('decrKey'); assert(result === 1, "Failed to decrement existing key"); pass("testDecrExistingKey passed"); } catch (error) { fail("testDecrExistingKey failed:", error); } }, // incr by amount testIncrByAmount = async function() { try { await puter.kv.set('incrKey', 1); const result = await puter.kv.incr('incrKey', 5); assert(result === 6, "Failed to increment key by amount"); pass("testIncrByAmount passed"); } catch (error) { fail("testIncrByAmount failed:", error); } }, // decr by amount testDecrByAmount = async function() { try { await puter.kv.set('decrKey', 10); const result = await puter.kv.decr('decrKey', 5); assert(result === 5, "Failed to decrement key by amount"); pass("testDecrByAmount passed"); } catch (error) { fail("testDecrByAmount failed:", error); } }, // incr by amount existing key testIncrByAmountExistingKey = async function() { try { await puter.kv.set('incrKey', 1); const result = await puter.kv.incr('incrKey', 5); assert(result === 6, "Failed to increment existing key by amount"); pass("testIncrByAmountExistingKey passed"); } catch (error) { fail("testIncrByAmountExistingKey failed:", error); } }, // decr by amount existing key testDecrByAmountExistingKey= async function() { try { await puter.kv.set('decrKey', 10); const result = await puter.kv.decr('decrKey', 5); assert(result === 5, "Failed to decrement existing key by amount"); pass("testDecrByAmountExistingKey passed"); } catch (error) { fail("testDecrByAmountExistingKey failed:", error); } }, // incr by negative amount testIncrByNegativeAmount = async function() { try { await puter.kv.set('incrKey', 1); const result = await puter.kv.incr('incrKey', -5); assert(result === -4, "Failed to increment key by negative amount"); pass("testIncrByNegativeAmount passed"); } catch (error) { fail("testIncrByNegativeAmount failed:", error); } }, // decr by negative amount testDecrByNegativeAmount = async function() { try { await puter.kv.set('decrKey', 10); const result = await puter.kv.decr('decrKey', -5); assert(result === 15, "Failed to decrement key by negative amount"); pass("testDecrByNegativeAmount passed"); } catch (error) { fail("testDecrByNegativeAmount failed:", error); } }, // list keys testListKeys = async function() { try { const keys = []; // flush first await puter.kv.flush(); // create 10 keys for(let i = 0; i < 10; i++){ keys.push('key' + i); } // set all keys await Promise.all(keys.map(key => puter.kv.set(key, 'value'))); // list keys const result = await puter.kv.list(); assert(result.length === 10, "Failed to list keys"); pass("testListKeys passed"); } catch (error) { fail("testListKeys failed:", error); } }, // list keys using glob testListKeysGlob = async function() { try { const keys = []; // flush first await puter.kv.flush(); // create 10 keys for(let i = 0; i < 10; i++){ keys.push('key' + i); } // set all keys await Promise.all(keys.map(key => puter.kv.set(key, 'value'))); // list keys const result = await puter.kv.list('k*'); assert(result.length === 10, "Failed to list keys using glob"); pass("testListKeysGlob passed"); } catch (error) { fail("testListKeysGlob failed:", error); } }, ]