How to use arrayToObject method in Playwright Internal

1var assert = require('chai').assert;
2
3var arrayToObject = require(`${__dirname}/../../../src/steps/arrayToObject`);
4
5describe('#arrayToObject', function () {
6
7    it('should convert array to object', function () {
8
9        var config = {
10            from: 'a',
11            to: 'b',
12            byKey: 'id'
13        };
14
15        var data = {
16            a: [{id: 1, login: 1}, {id: 2, login: 2}]
17        };
18
19        var result = {};
20
21        arrayToObject(config, data, result);
22
23        var valid = {
24            b: {
25                1: {id: 1, login: 1},
26                2: {id: 2, login: 2}
27            }
28        };
29
30        assert.deepEqual(valid, result);
31
32    });
33
34    it('should error on invalid config', function () {
35        var data = {
36            a: [{id: 1, login: 1}, {id: 2, login: 2}]
37        };
38
39        var result = {};
40
41        assert.throws(x => arrayToObject({}, data, result), Error, 'invalid config fo step "arrayToObject"');
42        assert.throws(x => arrayToObject({from: 'a'}, data, result), Error, 'invalid config fo step "arrayToObject"');
43        assert.throws(x => arrayToObject({to: 'a'}, data, result), Error, 'invalid config fo step "arrayToObject"');
44        assert.throws(x => arrayToObject({byKey: 'a'}, data, result), Error, 'invalid config fo step "arrayToObject"');
45    });
46});
47

Source: arrayToObject.js

var assert = require('chai').assert;

var arrayToObject = require(`${__dirname}/../../../src/steps/arrayToObject`);

describe('#arrayToObject', function () {

    it('should convert array to object', function () {

        var config = {
            from: 'a',
            to: 'b',
            byKey: 'id'
        };

        var data = {
            a: [{id: 1, login: 1}, {id: 2, login: 2}]
        };

        var result = {};

        arrayToObject(config, data, result);

        var valid = {
            b: {
                1: {id: 1, login: 1},
                2: {id: 2, login: 2}
            }
        };

        assert.deepEqual(valid, result);

    });

    it('should error on invalid config', function () {
        var data = {
            a: [{id: 1, login: 1}, {id: 2, login: 2}]
        };

        var result = {};

        assert.throws(x => arrayToObject({}, data, result), Error, 'invalid config fo step "arrayToObject"');
        assert.throws(x => arrayToObject({from: 'a'}, data, result), Error, 'invalid config fo step "arrayToObject"');
        assert.throws(x => arrayToObject({to: 'a'}, data, result), Error, 'invalid config fo step "arrayToObject"');
        assert.throws(x => arrayToObject({byKey: 'a'}, data, result), Error, 'invalid config fo step "arrayToObject"');
    });
});

1const { arrayToObject } = require("../lib");
2
3describe("arrayToObject", () => {
4  test("Should return an empty object", () => {
5    expect(arrayToObject()).toEqual({});
6    expect(arrayToObject([])).toEqual({});
7    expect(arrayToObject(null)).toEqual({});
8    expect(arrayToObject("fff")).toEqual({});
9    expect(arrayToObject(55)).toEqual({});
10  });
11
12  test("Should return an object with correct keys/values", () => {
13    let obj = [33, "foo", "bing"];
14    let withVal = ["33", "foo", ["bing", "free"]];
15    let withValObj = { "33": undefined, "foo": undefined, "bing": "free" };
16
17    expect(arrayToObject(obj)).toEqual({
18      "33": undefined,
19      "foo": undefined,
20      "bing": undefined,
21    });
22    expect(arrayToObject(withVal)).toEqual(withValObj);
23  });
24
25  test("Should return a nested object with correct keys/values", () => {
26    let arr = ["33", "foo", ["bing", "free", ["bop", 72]]];
27    let obj = { "33": undefined, "foo": undefined, "bing": { "free": undefined, "bop": 72 }};
28    let nestedArr = ["33", "foo", ["bing", "free", ["bop", 72, "bar"]]];
29    let nestedObj = { "33": undefined, "foo": undefined, "bing": { "free": undefined, "bop": { "72": undefined, "bar": undefined }}};
30
31    expect(arrayToObject(arr)).toEqual(obj);
32    expect(arrayToObject(nestedArr)).toEqual(nestedObj);
33  });
34});
35

Source: arrayToObject.test.js

const { arrayToObject } = require("../lib");

describe("arrayToObject", () => {
  test("Should return an empty object", () => {
    expect(arrayToObject()).toEqual({});
    expect(arrayToObject([])).toEqual({});
    expect(arrayToObject(null)).toEqual({});
    expect(arrayToObject("fff")).toEqual({});
    expect(arrayToObject(55)).toEqual({});
  });

  test("Should return an object with correct keys/values", () => {
    let obj = [33, "foo", "bing"];
    let withVal = ["33", "foo", ["bing", "free"]];
    let withValObj = { "33": undefined, "foo": undefined, "bing": "free" };

    expect(arrayToObject(obj)).toEqual({
      "33": undefined,
      "foo": undefined,
      "bing": undefined,
    });
    expect(arrayToObject(withVal)).toEqual(withValObj);
  });

  test("Should return a nested object with correct keys/values", () => {
    let arr = ["33", "foo", ["bing", "free", ["bop", 72]]];
    let obj = { "33": undefined, "foo": undefined, "bing": { "free": undefined, "bop": 72 }};
    let nestedArr = ["33", "foo", ["bing", "free", ["bop", 72, "bar"]]];
    let nestedObj = { "33": undefined, "foo": undefined, "bing": { "free": undefined, "bop": { "72": undefined, "bar": undefined }}};

    expect(arrayToObject(arr)).toEqual(obj);
    expect(arrayToObject(nestedArr)).toEqual(nestedObj);
  });
});

1'use strict';
2const arrayToObject = require('../../src/util/array-to-object');
3describe('arrayToObject', () => {
4	it('fills in an object by joining an array of properties with the names of the properties', () => {
5		expect(arrayToObject(['a', 'b', 'c'], ['na', 'nb', 'nc'])).toEqual({na: 'a', nb: 'b', nc: 'c'});
6	});
7	it('survives unequal length arrays', () => {
8		expect(arrayToObject(['a'], ['na', 'nb'])).toEqual({na: 'a'});
9		expect(arrayToObject(['a', 'b'], ['na'])).toEqual({na: 'a'});
10	});
11	it('survives empty arrays', () => {
12		expect(arrayToObject([], ['na', 'nb'])).toEqual({});
13		expect(arrayToObject(['a', 'b'], [])).toEqual({});
14	});
15	it('throws if arguments are not arrays', () => {
16		expect(() => arrayToObject({}, ['na'])).toThrowError(/values must be an array/);
17		expect(() => arrayToObject(['a'], {})).toThrowError(/names must be an array/);
18	});
19});
20

Source: array-to-object-spec.js

'use strict';
const arrayToObject = require('../../src/util/array-to-object');
describe('arrayToObject', () => {
	it('fills in an object by joining an array of properties with the names of the properties', () => {
		expect(arrayToObject(['a', 'b', 'c'], ['na', 'nb', 'nc'])).toEqual({na: 'a', nb: 'b', nc: 'c'});
	});
	it('survives unequal length arrays', () => {
		expect(arrayToObject(['a'], ['na', 'nb'])).toEqual({na: 'a'});
		expect(arrayToObject(['a', 'b'], ['na'])).toEqual({na: 'a'});
	});
	it('survives empty arrays', () => {
		expect(arrayToObject([], ['na', 'nb'])).toEqual({});
		expect(arrayToObject(['a', 'b'], [])).toEqual({});
	});
	it('throws if arguments are not arrays', () => {
		expect(() => arrayToObject({}, ['na'])).toThrowError(/values must be an array/);
		expect(() => arrayToObject(['a'], {})).toThrowError(/names must be an array/);
	});
});