@vida-global/core 2.5.0 → 3.0.1

package/test/search/query.test.js

@@ -0,0 +1,286 @@
+const { Query } = require('../../lib/search/query');
+const   TestHelpers = require('@vida-global/test-helpers');
+
+
+const randomString = () => TestHelpers.Faker.Text.randomString();
+const randomNumber = () => TestHelpers.Faker.Math.randomNumber();
+
+
+describe('Query', () => {
+    let client;
+    let query;
+
+
+    beforeEach(() => {
+        client = { fetch: jest.fn() };
+        query  = new Query(client);
+    });
+
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+
+    describe('#constructor', () => {
+        it('starts with an empty condition tree', () => {
+            expect(query.conditions).toEqual({and: [], or: [], not: [], options: {}});
+        });
+
+
+        it('adopts the conditions it is given', () => {
+            const conditions = {and: [{operator: 'exists', field: 'a'}], or: [], not: [], options: {}};
+
+            expect(new Query(client, conditions).conditions).toEqual(conditions);
+        });
+
+
+        it('does not share the empty tree between instances', () => {
+            new Query(client).conditions.and.push('mutated');
+
+            expect(new Query(client).conditions.and).toEqual([]);
+        });
+    });
+
+
+    describe('#conditions', () => {
+        it('returns a clone the caller cannot use to mutate the query', () => {
+            const conditions = query.conditions;
+            conditions.and.push('mutated');
+
+            expect(query.conditions.and).toEqual([]);
+        });
+    });
+
+
+    describe('#fetch', () => {
+        it('passes the conditions and the options to the client', async () => {
+            const options  = {indexWildcard: true};
+            const expected = query.equals('status', 'success');
+
+            await expected.fetch(options);
+
+            expect(client.fetch).toHaveBeenCalledTimes(1);
+            expect(client.fetch).toHaveBeenCalledWith(expected.conditions, options);
+        });
+
+
+        it('returns whatever the client returns', async () => {
+            const response = {total: randomNumber(), results: []};
+            client.fetch.mockResolvedValue(response);
+
+            await expect(query.fetch()).resolves.toBe(response);
+        });
+
+
+        it('does not hand the client a reference to its own conditions', async () => {
+            await query.equals('status', 'success').fetch();
+
+            const [passedConditions] = client.fetch.mock.calls[0];
+            passedConditions.and.push('mutated');
+
+            expect(query.conditions.and).toEqual([]);
+        });
+    });
+
+
+    describe('operators', () => {
+        const leaf = (field) => ({operator: 'exists', field});
+
+
+        it.each([
+            ['and'],
+            ['or'],
+            ['not'],
+        ])('%s returns a new Query and leaves the original alone', (operator) => {
+            const result = query[operator](leaf('a'));
+
+            expect(result).toBeInstanceOf(Query);
+            expect(result).not.toBe(query);
+            expect(query.conditions[operator]).toEqual([]);
+        });
+
+
+        it.each([
+            ['and'],
+            ['or'],
+            ['not'],
+        ])('%s accepts several conditions in one call', (operator) => {
+            const result = query[operator](leaf('a'), leaf('b'));
+
+            expect(result.conditions[operator]).toEqual([leaf('a'), leaf('b')]);
+        });
+
+
+        it('unwraps a Query argument into its condition tree', () => {
+            const group = new Query(client).equals('from', 'x').equals('to', 'y');
+
+            expect(query.or(group).conditions.or).toEqual([group.conditions]);
+        });
+
+
+        it('merges repeated or calls into one group', () => {
+            const result = query.or(leaf('a')).or(leaf('b'));
+
+            expect(result.conditions.or).toEqual([leaf('a'), leaf('b')]);
+        });
+    });
+
+
+    describe('conditions', () => {
+        it('equals builds a term leaf', () => {
+            const value = randomString();
+
+            expect(query.equals('status', value).conditions.and).toEqual([
+                {operator: 'equals', field: 'status', value}
+            ]);
+        });
+
+
+        it('in builds a leaf holding every value', () => {
+            const values = [randomString(), randomString()];
+
+            expect(query.in('roomId', values).conditions.and).toEqual([
+                {operator: 'in', field: 'roomId', value: values}
+            ]);
+        });
+
+
+        it('range builds a leaf holding the bounds', () => {
+            const bounds = {gte: 1, lte: 10};
+
+            expect(query.range('timestamp', bounds).conditions.and).toEqual([
+                {operator: 'range', field: 'timestamp', value: bounds}
+            ]);
+        });
+
+
+        it('exists builds a leaf with no value', () => {
+            expect(query.exists('canceledAt').conditions.and).toEqual([
+                {operator: 'exists', field: 'canceledAt'}
+            ]);
+        });
+
+
+        it('missing builds a leaf with no value', () => {
+            expect(query.missing('canceledAt').conditions.and).toEqual([
+                {operator: 'missing', field: 'canceledAt'}
+            ]);
+        });
+
+
+        it('matches defaults fuzziness to AUTO', () => {
+            const text = randomString();
+
+            expect(query.matches('message', text).conditions.and).toEqual([
+                {operator: 'matches', field: 'message', value: text, options: {fuzziness: 'AUTO'}}
+            ]);
+        });
+
+
+        it('matches keeps a fuzziness the caller supplies', () => {
+            const text = randomString();
+
+            expect(query.matches('message', text, {fuzziness: 2}).conditions.and).toEqual([
+                {operator: 'matches', field: 'message', value: text, options: {fuzziness: 2}}
+            ]);
+        });
+
+
+        it('phrase builds a leaf with no options', () => {
+            const text = randomString();
+
+            expect(query.phrase('message', text).conditions.and).toEqual([
+                {operator: 'phrase', field: 'message', value: text}
+            ]);
+        });
+
+
+        it('fullText gives every unboosted field a weight of one', () => {
+            const text = randomString();
+
+            expect(query.fullText(text, {fields: ['message', 'summary']}).conditions.and).toEqual([
+                {
+                    operator: 'fullText',
+                    field:    {message: 1, summary: 1},
+                    value:    text,
+                    options:  {wildcard: false}
+                }
+            ]);
+        });
+
+
+        it('fullText applies the boosts it is given', () => {
+            const text    = randomString();
+            const options = {fields: ['message', 'summary'], boost: {summary: 5}, wildcard: true};
+
+            expect(query.fullText(text, options).conditions.and).toEqual([
+                {
+                    operator: 'fullText',
+                    field:    {message: 1, summary: 5},
+                    value:    text,
+                    options:  {wildcard: true}
+                }
+            ]);
+        });
+
+
+        it('nested stores the sub-query condition tree', () => {
+            const subQuery = new Query(client).matches('addresses.address', 'home');
+
+            expect(query.nested('addresses', subQuery).conditions.and).toEqual([
+                {operator: 'nested', field: 'addresses', value: subQuery.conditions}
+            ]);
+        });
+
+
+        it('chains several conditions onto the and list in order', () => {
+            const result = query.equals('status', 'success').exists('summary');
+
+            expect(result.conditions.and).toEqual([
+                {operator: 'equals', field: 'status', value: 'success'},
+                {operator: 'exists', field: 'summary'}
+            ]);
+        });
+    });
+
+
+    describe('options', () => {
+        it.each([
+            ['limit'],
+            ['offset'],
+            ['minScore'],
+        ])('%s stores the value and returns a new Query', (option) => {
+            const value  = randomNumber();
+            const result = query[option](value);
+
+            expect(result).not.toBe(query);
+            expect(result.conditions.options[option]).toBe(value);
+        });
+
+
+        it('sort defaults the direction to desc', () => {
+            expect(query.sort('timestamp').conditions.options.sort).toEqual([
+                {field: 'timestamp', direction: 'desc'}
+            ]);
+        });
+
+
+        it('sort appends each key in the order it was added', () => {
+            const result = query.sort('score', 'asc').sort('timestamp');
+
+            expect(result.conditions.options.sort).toEqual([
+                {field: 'score',     direction: 'asc'},
+                {field: 'timestamp', direction: 'desc'}
+            ]);
+        });
+
+
+        it('keeps options and conditions together through a chain', () => {
+            const result = query.equals('status', 'success').limit(50).offset(100);
+
+            expect(result.conditions.and).toHaveLength(1);
+            expect(result.conditions.options).toEqual({limit: 50, offset: 100});
+        });
+    });
+});

package/test/search/serializer.test.js

@@ -0,0 +1,202 @@
+const { buildOpenSearchClient } = require('./helpers/searchClient');
+const   TestHelpers             = require('@vida-global/test-helpers');
+
+
+/***************************************************************************************************
+* Every query here is one of vida.live's hand-written OpenSearch bodies, rebuilt through the
+* condition vocabulary. The expectations are the corrected bodies: vida.live keys two match_phrase
+* clauses on "message^10", which is not a field name, so those clauses have never matched.
+***************************************************************************************************/
+const MESSAGE_FIELDS = ['message', 'fromUser', 'toUser', 'summary', 'callDialog'];
+const MESSAGE_BOOST  = {message: 4, fromUser: 5, toUser: 5, summary: 5, callDialog: 5};
+
+const ACCOUNT_FIELDS = [
+    'username',
+    'vidaPhoneNumber',
+    'details.description',
+    'details.name',
+    'details.orgName',
+    'details.resellerName',
+    'details.partnerName'
+];
+const ACCOUNT_BOOST = {username: 10, vidaPhoneNumber: 10};
+
+
+const randomString = () => TestHelpers.Faker.Text.randomString();
+const randomNumber = () => TestHelpers.Faker.Math.randomNumber();
+
+
+describe('OpenSearchClient serialization of vida.live queries', () => {
+    let client;
+
+
+    beforeEach(() => {
+        client = buildOpenSearchClient();
+    });
+
+
+    describe('textSearchMessage', () => {
+        const buildQuery = (queryText, userId) => {
+            const userMatch = client.query().or(
+                client.query().equals('from', userId),
+                client.query().equals('to',   userId),
+                client.query().equals('user', userId)
+            );
+
+            const keywordMatch = client.query().or(
+                client.query().fullText(queryText, {
+                    fields:   MESSAGE_FIELDS,
+                    boost:    MESSAGE_BOOST,
+                    wildcard: true
+                }),
+                client.query().phrase('message', queryText),
+                ...MESSAGE_FIELDS.map(field => client.query().matches(field, queryText))
+            );
+
+            return client.query().equals('status', 'success').and(userMatch, keywordMatch);
+        };
+
+
+        it('builds the same must/should tree the hand-written body builds', () => {
+            const queryText = randomString();
+            const userId    = randomString();
+
+            const body = client._serializeConditions(buildQuery(queryText, userId).conditions);
+
+            expect(body.query).toEqual({
+                bool: {
+                    must: [
+                        {term: {status: {value: 'success'}}},
+                        {
+                            bool: {
+                                should: [
+                                    {term: {from: {value: userId}}},
+                                    {term: {to:   {value: userId}}},
+                                    {term: {user: {value: userId}}}
+                                ],
+                                minimum_should_match: 1
+                            }
+                        },
+                        {
+                            bool: {
+                                should: [
+                                    {
+                                        query_string: {
+                                            query:  `*${queryText}*`,
+                                            fields: [
+                                                'message^4',
+                                                'fromUser^5',
+                                                'toUser^5',
+                                                'summary^5',
+                                                'callDialog^5'
+                                            ]
+                                        }
+                                    },
+                                    {match_phrase: {message: {query: queryText}}},
+                                    ...MESSAGE_FIELDS.map(field => ({
+                                        match: {[field]: {query: queryText, fuzziness: 'AUTO'}}
+                                    }))
+                                ],
+                                minimum_should_match: 1
+                            }
+                        }
+                    ],
+                    must_not: []
+                }
+            });
+        });
+
+
+        it('asks for an exact total and sends no paging keys', () => {
+            const body = client._serializeConditions(buildQuery('x', 'y').conditions);
+
+            expect(body.track_total_hits).toBe(true);
+            expect(body).not.toHaveProperty('size');
+            expect(body).not.toHaveProperty('sort');
+        });
+    });
+
+
+    describe('searchAccountsWithFilters', () => {
+        const buildQuery = (queryText, organizationId, pageSize, pageNumber) => {
+            const textMatch = client.query().or(
+                client.query().fullText(queryText, {
+                    fields:   ACCOUNT_FIELDS,
+                    boost:    ACCOUNT_BOOST,
+                    wildcard: true
+                }),
+                client.query().phrase('details.description', queryText),
+                client.query().phrase('details.name', queryText)
+            );
+
+            return client.query()
+                .and(textMatch)
+                .equals('organizationId.keyword', organizationId)
+                .range('timestamp', {gte: 1, lte: 9})
+                .exists('configIssues.count')
+                .not(
+                    client.query().exists('unregistered'),
+                    client.query().equals('tempUser', true)
+                )
+                .sort('timestamp', 'desc')
+                .limit(pageSize)
+                .offset(pageNumber * pageSize);
+        };
+
+
+        it('keeps every filter in must and both exclusions in must_not', () => {
+            const queryText      = randomString();
+            const organizationId = randomString();
+
+            const body = client._serializeConditions(buildQuery(queryText, organizationId, 25, 2).conditions);
+
+            expect(body.query.bool.must).toEqual([
+                {
+                    bool: {
+                        should: [
+                            {
+                                query_string: {
+                                    query:  `*${queryText}*`,
+                                    fields: [
+                                        'username^10',
+                                        'vidaPhoneNumber^10',
+                                        'details.description^1',
+                                        'details.name^1',
+                                        'details.orgName^1',
+                                        'details.resellerName^1',
+                                        'details.partnerName^1'
+                                    ]
+                                }
+                            },
+                            {match_phrase: {'details.description': {query: queryText}}},
+                            {match_phrase: {'details.name': {query: queryText}}}
+                        ],
+                        minimum_should_match: 1
+                    }
+                },
+                {term: {'organizationId.keyword': {value: organizationId}}},
+                {range: {timestamp: {gte: 1, lte: 9}}},
+                {exists: {field: 'configIssues.count'}}
+            ]);
+
+            expect(body.query.bool.must_not).toEqual([
+                {exists: {field: 'unregistered'}},
+                {term: {tempUser: {value: true}}}
+            ]);
+        });
+
+
+        it('turns the page number and page size into from and size', () => {
+            const pageSize   = randomNumber() + 1;
+            const pageNumber = randomNumber();
+
+            const body = client._serializeConditions(
+                buildQuery('x', 'y', pageSize, pageNumber).conditions
+            );
+
+            expect(body.size).toBe(pageSize);
+            expect(body.from).toBe(pageNumber * pageSize);
+            expect(body.sort).toEqual([{timestamp: {order: 'desc'}}]);
+        });
+    });
+});

package/test/server/authorizer.test.js

@@ -0,0 +1,105 @@
+const { Authorizer }                     = require('../../lib/server/authorizer');
+const { Gadget, TestAuthorizer, Widget } = require('./helpers/authorizer');
+const   TestHelpers                      = require('@vida-global/test-helpers');
+
+
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+
+
+describe('Authorizer', () => {
+    describe('#can', () => {
+        let action;
+        let authorizer;
+
+        beforeEach(() => {
+            action     = TestHelpers.Faker.Text.randomString();
+            authorizer = new TestAuthorizer();
+        });
+
+        it ('returns false when there is no scope', async () => {
+            await expect(authorizer.can(action)).resolves.toBe(false);
+        });
+
+        it ('dispatches to the permission method named for the class of the scope instance', async () => {
+            const scope     = new Widget();
+            const widgetSpy = jest.spyOn(authorizer, 'widgetPermission');
+
+            await authorizer.can(action, scope);
+
+            expect(widgetSpy).toHaveBeenCalledTimes(1);
+            expect(widgetSpy).toHaveBeenCalledWith(action, scope);
+        });
+
+        it ('dispatches to the same permission method when the scope is the class itself', async () => {
+            const widgetSpy = jest.spyOn(authorizer, 'widgetPermission');
+
+            await authorizer.can(action, Widget);
+
+            expect(widgetSpy).toHaveBeenCalledTimes(1);
+            expect(widgetSpy).toHaveBeenCalledWith(action, Widget);
+        });
+
+        it ('falls back to defaultPermission when no method matches the class of the scope', async () => {
+            const scope      = new Gadget();
+            const defaultSpy = jest.spyOn(authorizer, 'defaultPermission');
+
+            await authorizer.can(action, scope);
+
+            expect(defaultSpy).toHaveBeenCalledTimes(1);
+            expect(defaultSpy).toHaveBeenCalledWith(action, scope);
+        });
+
+        it ('returns the value from a synchronous permission method', async () => {
+            jest.spyOn(authorizer, 'widgetPermission').mockReturnValue(true);
+
+            await expect(authorizer.can(action, new Widget())).resolves.toBe(true);
+        });
+
+        it ('returns the resolved value from an asynchronous permission method', async () => {
+            jest.spyOn(authorizer, 'widgetPermission').mockResolvedValue(true);
+
+            await expect(authorizer.can(action, new Widget())).resolves.toBe(true);
+        });
+    });
+
+
+    describe('#defaultPermission', () => {
+        it ('returns false', () => {
+            const authorizer = new Authorizer();
+            const action     = TestHelpers.Faker.Text.randomString();
+
+            expect(authorizer.defaultPermission(action, new Widget())).toBe(false);
+        });
+    });
+
+
+    describe('#classForScope', () => {
+        const authorizer = new Authorizer();
+
+        it ('returns the constructor when the scope is an instance', () => {
+            expect(authorizer.classForScope(new Widget())).toBe(Widget);
+        });
+
+        it ('returns the class when the scope is a class', () => {
+            expect(authorizer.classForScope(Widget)).toBe(Widget);
+        });
+
+        it ('returns the scope unchanged when the scope is falsy', () => {
+            expect(authorizer.classForScope(null)).toBeNull();
+        });
+    });
+
+
+    describe('#currentUser / #adminUser', () => {
+        it ('exposes the users passed to the constructor', () => {
+            const currentUser = {id: TestHelpers.Faker.Text.randomString()};
+            const adminUser   = {id: TestHelpers.Faker.Text.randomString()};
+            const authorizer  = new Authorizer(currentUser, adminUser);
+
+            expect(authorizer.currentUser).toBe(currentUser);
+            expect(authorizer.adminUser).toBe(adminUser);
+        });
+    });
+});

package/test/server/helpers/authorizer.js

@@ -0,0 +1,19 @@
+const { Authorizer } = require('../../../lib/server/authorizer');
+
+
+class Widget {}
+
+
+class Gadget {}
+
+
+class TestAuthorizer extends Authorizer {
+    widgetPermission() {}
+}
+
+
+module.exports = {
+    Gadget,
+    TestAuthorizer,
+    Widget
+}