acebase/spec/keys.spec.js

/// <reference types="@types/jasmine" />
const { createTempDB } = require('./tempdb');

describe('Keys', () => {
    let db, removeDB;
    beforeAll(async () => {
        const tmp = await createTempDB();
        db = tmp.db;
        removeDB = tmp.removeDB;
    });

    it('should allow unicode characters', async () => {

        // Create unicode keys
        const unicodeKeys = {
            'AceBaseはクールです': 'AceBase is cool (in Japanese)',
            'I💗AceBase': 'I (heart) AceBase',
        };
        let p = db.ref('unicode').set(unicodeKeys);
        await expectAsync(p).toBeResolved();

        // Load Unicode keys
        let snap = await db.ref('unicode').get();
        expect(snap.val()).toEqual(unicodeKeys);

        // Load a single unicode key
        snap = await db.ref('unicode/I💗AceBase').get();
        expect(snap.val()).toEqual(unicodeKeys['I💗AceBase']);

    });

    it('should not allow special characters \\ / [ ] ', async () => {

        let p = db.ref('invalid').set({ 'forward/slash': 'Forward slashes are used to access nested objects' });
        await expectAsync(p).toBeRejected();

        p = db.ref('invalid').set({ 'back\\slash': 'Using backslashes would be confusing because of the special meaning of the forward slash' });
        await expectAsync(p).toBeRejected();

        p = db.ref('invalid').set({ '[brackets]': 'Brackets are used to access array indexes' });
        await expectAsync(p).toBeRejected();

    });

    it('should not allow keys larger than 128 bytes', async () => {

        let max = '';
        for (let i = 0; i < 128; i++) {
            max += i % 10;
        }
        let tooLong = max + 'x';

        let p = db.ref('key_length').set({ [max]: 'This is the maximum length for a key' });
        await expectAsync(p).toBeResolved();

        p = db.ref('key_length').set({ [tooLong]: 'This key is too long to store' });
        await expectAsync(p).toBeRejected();

    });

    describe('control character', () => {
        for (let cc = 0; cc < 32; cc++) {
            const prop = `control${String.fromCharCode(cc)}`;
            let allow = [9,10,13].includes(cc); // allow tab (9, \t), line feed (10, \n), carriage return (13, \r)

            it(`${cc} must ${!allow && 'NOT'} be allowed`, async () => {
                let p = db.ref('control').set({ [prop]: 'Using control characters would be weird' });
                if (allow) {
                    await expectAsync(p).toBeResolved();
                }
                else {
                    await expectAsync(p).toBeRejected();
                }
            });
        }
    });

    it('should allow .', async () => {

        let p = db.ref('dots').set({ 'dot.dot': 'Using dots would be confusing, but should be allowed' });
        await expectAsync(p).toBeResolved();

    });

    it('should allow whitespaces', async () => {

        let p = db.ref('whitespace').set({ 'Something with spaces': 'Spaces in keys could cause confusion, but should be allowed' });
        await expectAsync(p).toBeResolved();

        p = db.ref('whitespace').set({ 'Something\twith\ttabs': 'Tabs in keys would be weird, but should be allowed' });
        await expectAsync(p).toBeResolved();

        p = db.ref('whitespace').set({ 'Something\nwith\nnewline\nchars': 'New lines in keys would be weird, but should be allowed' });
        await expectAsync(p).toBeResolved();
    });

    it('should be case sensitive', async () => {

        const lowercase = { key: 'casesensitive', value: 'the key has lowercase chars' };
        const camelcase = { key: 'caseSensitive', value: 'the key has camelCase chars' };
        const pascalcase = { key: 'CaseSensitive', value: 'the key has PascalCase chars' };
        const uppercase = { key: 'CASESENSITIVE', value: 'the key has UPPERCASE chars' };

        await db.ref(lowercase.key).set(lowercase.value);
        await db.ref(camelcase.key).set(camelcase.value);
        await db.ref(pascalcase.key).set(pascalcase.value);
        await db.ref(uppercase.key).set(uppercase.value);

        let snap = await db.ref(lowercase.key).get();
        expect(snap.val()).toEqual(lowercase.value);

        snap = await db.ref(camelcase.key).get();
        expect(snap.val()).toEqual(camelcase.value);

        snap = await db.ref(pascalcase.key).get();
        expect(snap.val()).toEqual(pascalcase.value);

        snap = await db.ref(uppercase.key).get();
        expect(snap.val()).toEqual(uppercase.value);

    });

    afterAll(async () => {
        await removeDB();
    });
});