arb-convert/dist/util/__tests__/xmlQuery.test.js

Convert Application Resource Bundle (ARB) translation files to other translation formats and back

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var xmlQuery_1 = __importDefault(require("../xmlQuery"));
test('wrapping an element adds new properties and functions', function () {
    var el = {
        type: 'element',
        name: 'foo',
    };
    var node = xmlQuery_1.default(el);
    expect(node).toMatchObject(__assign(__assign({}, el), { originalNode: el }));
});
test('returns an already wrapped instance directly', function () {
    var el = {
        type: 'element',
        name: 'foo',
    };
    var node = xmlQuery_1.default(el);
    expect(xmlQuery_1.default(node)).toBe(node);
});
test('returns wrapped instance for primitive', function () {
    expect(xmlQuery_1.default(undefined)).toMatchObject({
        originalNode: undefined,
        elements: [],
        attributes: {},
    });
    expect(xmlQuery_1.default('foobar')).toMatchObject({
        originalNode: 'foobar',
        elements: [],
        attributes: {},
    });
    expect(xmlQuery_1.default(123)).toMatchObject({
        originalNode: 123,
        elements: [],
        attributes: {},
    });
});
describe('handles arrays of Elements correctly', function () {
    var elements = [{
            type: 'element',
            name: 'foo',
            elements: [{
                    type: 'element',
                    name: 'first',
                }, {
                    type: 'text',
                    text: 'inner',
                }],
        }, {
            type: 'element',
            name: 'bar',
            elements: [{
                    type: 'element',
                    name: 'second',
                }, {
                    type: 'text',
                    text: 'inner2',
                }],
        }, {
            type: 'element',
            name: 'baz',
            elements: [{
                    type: 'element',
                    name: 'third',
                }],
        }, {
            type: 'text',
            text: 'outer',
        }];
    test('wraps arrays of Elements correctly', function () {
        var node = xmlQuery_1.default(elements);
        expect(node.name).toBeUndefined();
        expect(node.originalNode).toBe(elements);
        expect(node.elements).toHaveLength(4);
        expect(node.elements).toMatchObject([
            {
                type: 'element',
                name: 'foo',
            },
            {
                type: 'element',
                name: 'bar',
            },
            {
                type: 'element',
                name: 'baz',
            },
            {
                type: 'text',
                text: 'outer',
            },
        ]);
    });
    test('innerElements on array of elements', function () {
        var node = xmlQuery_1.default(elements);
        expect(node.innerElements()).toEqual([{
                type: 'element',
                name: 'first',
            }, {
                type: 'text',
                text: 'inner',
            }, {
                type: 'element',
                name: 'second',
            }, {
                type: 'text',
                text: 'inner2',
            }, {
                type: 'element',
                name: 'third',
            }]);
    });
    test('innerText on array of elements', function () {
        var node = xmlQuery_1.default(elements);
        expect(node.innerText()).toBe('innerinner2');
    });
    test('query on array of elements', function () {
        var node = xmlQuery_1.default(elements);
        var expectedElement = {
            type: 'element',
            name: 'first',
        };
        expect(node.query('first')).toMatchObject(expectedElement);
        expect(node.query(0)).toMatchObject(expectedElement);
        expect(node.query(function (nd) { return nd.name === 'first'; })).toMatchObject(expectedElement);
    });
    test('queryAll on array of elements', function () {
        var node = xmlQuery_1.default(elements);
        var expectedElements = {
            elements: [{
                    type: 'element',
                    name: 'first',
                }],
        };
        expect(node.queryAll('first')).toMatchObject(expectedElements);
        expect(node.queryAll(0)).toMatchObject(expectedElements);
        expect(node.queryAll(function (nd) { return nd.name === 'first'; })).toMatchObject(expectedElements);
    });
    test('forEach on array of elements', function () {
        var node = xmlQuery_1.default(elements);
        node.forEach(function (el, index) {
            expect(el).toMatchObject(elements[index]);
        });
    });
    test('map on array of elements', function () {
        var node = xmlQuery_1.default(elements);
        var result = node.map(function (el, index) {
            expect(el).toMatchObject(elements[index]);
            return el.name;
        });
        var resultExpected = ['foo', 'bar', 'baz', undefined];
        expect(result.originalNode).toEqual(resultExpected);
        expect(result.elements).toEqual(resultExpected);
        var result2 = node.map(function (el, index) {
            expect(el).toMatchObject(elements[index]);
            return el.elements[0];
        });
        var result2Expected = [
            { type: 'element', name: 'first' },
            { type: 'element', name: 'second' },
            { type: 'element', name: 'third' },
            undefined,
        ];
        expect(result2.originalNode).toEqual(result2Expected);
        expect(result2.elements).toEqual(result2Expected);
    });
});
describe('handles single Elements correctly', function () {
    var element = {
        type: 'element',
        name: 'outer',
        elements: [{
                type: 'element',
                name: 'inner',
                elements: [{
                        type: 'element',
                        name: 'deep inner',
                    }],
            }, {
                type: 'text',
                text: 'wubba lubba dub dub',
            }],
    };
    test('wraps element correctly', function () {
        var node = xmlQuery_1.default(element);
        expect(node.name).toBe('outer');
        expect(node.originalNode).toBe(element);
        expect(node.elements).toHaveLength(2);
        expect(node.elements).toMatchObject([{
                type: 'element',
                name: 'inner',
            }, {
                type: 'text',
                text: 'wubba lubba dub dub',
            }]);
    });
    test('innerElements on element', function () {
        var node = xmlQuery_1.default(element);
        expect(node.innerElements()).toEqual([{
                type: 'element',
                name: 'inner',
                elements: [{
                        type: 'element',
                        name: 'deep inner',
                    }],
            }, {
                type: 'text',
                text: 'wubba lubba dub dub',
            }]);
    });
    test('innerText on element', function () {
        var node = xmlQuery_1.default(element);
        expect(node.innerText()).toBe('wubba lubba dub dub');
    });
    test('query on element', function () {
        var node = xmlQuery_1.default(element);
        var expectedElement = {
            type: 'element',
            name: 'inner',
        };
        expect(node.query('inner')).toMatchObject(expectedElement);
        expect(node.query(0)).toMatchObject(expectedElement);
        expect(node.query(function (nd) { return nd.name === 'inner'; })).toMatchObject(expectedElement);
    });
    test('queryAll on element', function () {
        var node = xmlQuery_1.default(element);
        var expectedElements = {
            elements: [{
                    type: 'element',
                    name: 'inner',
                }],
        };
        expect(node.queryAll('inner')).toMatchObject(expectedElements);
        expect(node.queryAll(0)).toMatchObject(expectedElements);
        expect(node.queryAll(function (nd) { return nd.name === 'inner'; })).toMatchObject(expectedElements);
    });
    test('forEach on element', function () {
        var node = xmlQuery_1.default(element);
        node.forEach(function (el, index) {
            expect(el).toMatchObject(element.elements[index]);
        });
    });
    test('map on element', function () {
        var node = xmlQuery_1.default(element);
        var result = node.map(function (el, index) {
            expect(el).toMatchObject(element.elements[index]);
            return el.name;
        });
        var resultExpected = ['inner', undefined];
        expect(result.originalNode).toEqual(resultExpected);
        expect(result.elements).toEqual(resultExpected);
        var result2 = node.map(function (el, index) {
            expect(el).toMatchObject(element.elements[index]);
            return el.elements[0];
        });
        var result2Expected = [
            { type: 'element', name: 'deep inner' },
            undefined,
        ];
        expect(result2.originalNode).toEqual(result2Expected);
        expect(result2.elements).toEqual(result2Expected);
    });
});
describe('handles primitives correctly', function () {
    test('wraps primitive correctly', function () {
        var node = xmlQuery_1.default('foo');
        expect(node.name).toBeUndefined();
        expect(node.originalNode).toBe('foo');
        expect(node.elements).toHaveLength(0);
    });
    test('innerElements on primitive', function () {
        var node = xmlQuery_1.default('foo');
        expect(node.innerElements()).toEqual([]);
    });
    test('innerText on primitive', function () {
        var node = xmlQuery_1.default('foo');
        expect(node.innerText()).toBe('');
    });
    test('query on primitive', function () {
        var node = xmlQuery_1.default('foo');
        expect(node.query('first')).toMatchObject({ originalNode: undefined, elements: [] });
        expect(node.query(0)).toMatchObject({ originalNode: undefined, elements: [] });
        expect(node.query(function (nd) { return nd.name === 'first'; })).toMatchObject({ originalNode: undefined, elements: [] });
    });
    test('queryAll on primitive', function () {
        var node = xmlQuery_1.default('foo');
        expect(node.queryAll('first')).toMatchObject({ originalNode: [], elements: [] });
        expect(node.queryAll(0)).toMatchObject({ originalNode: [undefined], elements: [undefined] });
        expect(node.queryAll(function (nd) { return nd.name === 'first'; })).toMatchObject({ originalNode: [], elements: [] });
    });
    test('forEach on primitive', function () {
        var node = xmlQuery_1.default('foo');
        var result = [];
        node.forEach(function (el) { return result.push(el); });
        expect(result).toEqual([]);
    });
    test('map on primitive', function () {
        var node = xmlQuery_1.default('foo');
        var result = node.map(function (el) { return el.name; });
        expect(result.originalNode).toEqual([]);
        expect(result.elements).toEqual([]);
    });
});