@vida-global/core 2.3.2 → 2.3.4

package/test/activeRecord/db/migrator.test.js

@@ -177,6 +177,48 @@ describe('Migrator', () => {
                 .rejects.toThrow(`Unknown id type "${idType}". Use one of: bigint, int, uuid`);
         });
 
+        it ('tells the caller false is an option when refusing an id type', async () => {
+            await expect(Helpers.migrator.createTable(Helpers.randomString(), {}, { id: Helpers.randomString() }))
+                .rejects.toThrow('or false for a table that declares its own primary key');
+        });
+
+        // For a table whose primary key is a natural column, e.g. a baseline migration recreating
+        // a table that predates the migrations directory.
+        it ('adds no id column when id is false', async () => {
+            const tableName = Helpers.randomString();
+
+            await Helpers.migrator.createTable(tableName, {}, { id: false });
+
+            const [, columns] = Helpers.mockQueryInterface.createTable.mock.calls[0];
+            expect(columns).not.toHaveProperty('id');
+        });
+
+        it ('keeps the table details when id is false', async () => {
+            const tableName = Helpers.randomString();
+            const uuid      = { allowNull: false, primaryKey: true, type: 'UUID' };
+
+            await Helpers.migrator.createTable(tableName, { uuid }, { id: false, timestamps: false });
+
+            expect(Helpers.mockQueryInterface.createTable).toHaveBeenCalledWith(
+                tableName, { uuid }, Helpers.noTransaction,
+            );
+        });
+
+        const notFalseCases = [['null', null], ['zero', 0], ['an empty string', '']];
+        it.each(notFalseCases)('does not treat %s as false', async (_label, idType) => {
+            await expect(Helpers.migrator.createTable(Helpers.randomString(), {}, { id: idType }))
+                .rejects.toThrow('Unknown id type');
+        });
+
+        it ('still defaults to a bigint id when no id option is given', async () => {
+            const tableName = Helpers.randomString();
+
+            await Helpers.migrator.createTable(tableName, {}, {});
+
+            const [, columns] = Helpers.mockQueryInterface.createTable.mock.calls[0];
+            expect(columns.id).toEqual({ allowNull: false, autoIncrement: true, primaryKey: true, type: 'BIGINT' });
+        });
+
         it ('lets the details override the id column', async () => {
             const tableName = Helpers.randomString();
             const id        = { allowNull: false, primaryKey: true, type: 'UUID' };

package/test/activeRecord/helpers/afterCommitHooks.js

@@ -0,0 +1,47 @@
+const TestHelpers = require('@vida-global/test-helpers');
+
+
+/***************************************************************************************************
+* MOCKS
+***************************************************************************************************/
+function buildTransaction() {
+    return { afterCommit: jest.fn(), parent: null };
+}
+
+
+function buildSavepoint(parent) {
+    return { afterCommit: jest.fn(), parent };
+}
+
+
+// The callbacks module keys everything off the model class itself, so any class works as a stand in.
+function buildModel(parent) {
+    if (parent) return class Child extends parent {};
+
+    return class Model {};
+}
+
+
+function buildRecord() {
+    return { id: TestHelpers.Faker.Text.randomString() };
+}
+
+
+/***************************************************************************************************
+* ASSERTIONS
+***************************************************************************************************/
+// Nothing runs until the transaction commits, so tests drive the deferred callbacks by hand.
+async function commit(transaction) {
+    for (const [deferred] of transaction.afterCommit.mock.calls) {
+        await deferred();
+    }
+}
+
+
+module.exports = {
+    buildModel,
+    buildRecord,
+    buildSavepoint,
+    buildTransaction,
+    commit,
+}

package/test/activeRecord/helpers/baseRecordMocks.js

@@ -27,6 +27,8 @@ class MockModel {
         }
     };
     static addHook             = jest.fn()
+    static removeHook          = jest.fn()
+    static hasHook             = jest.fn()
     static init                = jest.fn()
     static findByPk            = jest.fn();
     static findAll             = jest.fn();

package/test/server/controllerMixins/renderer.test.js

@@ -494,6 +494,68 @@ describe('VidaServerController', () => {
             expect(controller._toXMLElementName('first name')).toBe('first_name');
             expect(controller._toXMLElementName('a:b')).toBe('a_b');
         });
+
+
+        // xmlbuilder2 reads these prefixes as instructions rather than as part of the name.
+        // Sanitizing one away silently turns an intended attribute into a child element.
+        const prefixCases = [
+            ['attribute',              '@', '@track',   'both'],
+            ['text',                   '#', '#text',    'value'],
+            ['cdata',                  '$', '$cdata',   'value'],
+            ['comment',                '!', '!comment', 'value'],
+            ['processing instruction', '?', '?target',  'value'],
+        ];
+        it.each(prefixCases)('preserves the %s prefix', (_label, _prefix, key) => {
+            expect(controller._toXMLElementName(key)).toBe(key);
+        });
+
+        it ('sanitizes the name after the prefix but keeps the prefix', () => {
+            expect(controller._toXMLElementName('@my attr')).toBe('@my_attr');
+            expect(controller._toXMLElementName('@a:b')).toBe('@a_b');
+        });
+
+        it ('underscores a prefixed name that starts with a digit', () => {
+            expect(controller._toXMLElementName('@123')).toBe('@_123');
+        });
+
+        it ('returns a bare prefix untouched', () => {
+            expect(controller._toXMLElementName('@')).toBe('@');
+            expect(controller._toXMLElementName('#')).toBe('#');
+        });
+
+        it ('only treats a prefix as a prefix in the leading position', () => {
+            expect(controller._toXMLElementName('track@')).toBe('track_');
+            expect(controller._toXMLElementName('a#b')).toBe('a_b');
+        });
+    });
+
+
+    // The end-to-end reason the prefixes are preserved: without it these render as child
+    // elements (<_track>both</_track>) rather than attributes.
+    describe('#renderXMLResponse attribute rendering', () => {
+        it ('renders @-prefixed keys as XML attributes', async () => {
+            const response   = buildResponseMock();
+            const controller = new FooController({query: {_format: 'xml'}}, response);
+            controller.formatResponseBody = body => body;
+
+            await controller.render({Record: {'@track': 'both', '@trim': 'do-not-trim'}});
+
+            expect(response.send).toHaveBeenCalledWith(
+                expect.stringContaining('<Record track="both" trim="do-not-trim"/>')
+            );
+        });
+
+        it ('still renders an ordinary key as a child element', async () => {
+            const response   = buildResponseMock();
+            const controller = new FooController({query: {_format: 'xml'}}, response);
+            controller.formatResponseBody = body => body;
+
+            await controller.render({Record: {'weird key!': 'x'}});
+
+            expect(response.send).toHaveBeenCalledWith(
+                expect.stringContaining('<weird_key_>x</weird_key_>')
+            );
+        });
     });
 
 

package/test/server/controllerMixins/requestDetails.test.js

@@ -88,6 +88,72 @@ describe('VidaServerController', () => {
         });
 
 
+        describe('#requestHost', () => {
+            it ('returns the host request header', () => {
+                request.headers.host = `${TestHelpers.Faker.Text.randomString()}.vida.dev`;
+                expect(controller.requestHost).toEqual(request.headers.host);
+            });
+        });
+
+
+        describe('#forwardedProtocol', () => {
+            it ('returns null when the proxy sends no forwarded protocol', () => {
+                delete request.headers['x-forwarded-proto'];
+                expect(controller.forwardedProtocol).toBe(null);
+            });
+
+            it ('returns the forwarded protocol', () => {
+                request.headers['x-forwarded-proto'] = 'https';
+                expect(controller.forwardedProtocol).toEqual('https');
+            });
+
+            it ('returns only the first entry of a forwarded protocol chain', () => {
+                request.headers['x-forwarded-proto'] = 'https, http';
+                expect(controller.forwardedProtocol).toEqual('https');
+            });
+        });
+
+
+        describe('#isProxiedRequest', () => {
+            it.each([
+                ['x-forwarded-for is present', '203.0.113.7', true],
+                ['x-forwarded-for is absent',  undefined,     false],
+            ])('returns %s -> %s', (_label, forwardedFor, expected) => {
+                delete request.headers['x-forwarded-for'];
+                if (forwardedFor) request.headers['x-forwarded-for'] = forwardedFor;
+                expect(controller.isProxiedRequest).toBe(expected);
+            });
+        });
+
+
+        describe('#requestUrl', () => {
+            beforeEach(() => {
+                request.headers.host = 'api.vida.dev';
+                request.originalUrl  = '/things?page=2';
+                request.protocol     = 'http';
+                delete request.headers['x-forwarded-proto'];
+                delete request.headers['x-forwarded-for'];
+            });
+
+            it ('uses the forwarded protocol when the proxy sends one', () => {
+                request.headers['x-forwarded-proto'] = 'https';
+                request.headers['x-forwarded-for']   = '203.0.113.7';
+                expect(controller.requestUrl).toEqual('https://api.vida.dev/things?page=2');
+            });
+
+            // Not every balancer forwards X-Forwarded-Proto, so a proxied request can look like
+            // plain http even though the caller addressed an https URL.
+            it ('assumes https for a proxied request that carries no forwarded protocol', () => {
+                request.headers['x-forwarded-for'] = '203.0.113.7';
+                expect(controller.requestUrl).toEqual('https://api.vida.dev/things?page=2');
+            });
+
+            it ('keeps the connection protocol for a direct request with no proxy headers', () => {
+                expect(controller.requestUrl).toEqual('http://api.vida.dev/things?page=2');
+            });
+        });
+
+
         describe('#statusCode', () => {
             it ('returns the response status code', () => {
                 expect(controller.statusCode).toEqual(response.statusCode);