@autofleet/zehut 3.1.2 → 3.2.0

package/lib/user/api-user-flows.test.js

@@ -1,302 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const uuid_1 = require("uuid");
-const express_1 = __importDefault(require("express"));
-const axios_1 = __importDefault(require("axios"));
-const index_1 = require("../index");
-const index_2 = require("./index");
-const services_1 = require("../services");
-jest.spyOn(services_1.IdentityNetwork, 'get').mockImplementation(async (url) => {
-    if (url.includes('/api/v1/users/')) {
-        return {
-            data: {
-                accountType: 'user',
-                fleets: {},
-                businessModels: {},
-                demandSources: {},
-            },
-        };
-    }
-    return { data: {} };
-});
-const generateApp = async (addEndpoints, port) => {
-    const app = (0, express_1.default)();
-    addEndpoints(app);
-    const server = await new Promise((resolve) => {
-        const s = app.listen(port, () => {
-            console.log('Listen on port', port);
-            resolve(s);
-        });
-    });
-    return () => server.close();
-};
-describe('E2E', () => {
-    it('Basic functionality', async () => {
-        let server2TraceId = null;
-        const [uuid1, uuid2] = [(0, uuid_1.v4)(), (0, uuid_1.v4)()];
-        (0, index_1.enableTracing)({
-            outbreakOptions: {
-                headersPrefix: 'x-af-',
-            },
-        });
-        const closeServer1 = await generateApp((app) => {
-            app.use((0, index_2.middleware)());
-            app.get('/', async (req, res) => {
-                const user = (0, index_1.getUser)();
-                const closeElevation1 = user.elevatePermissions({
-                    businessModels: {
-                        [uuid1]: ['vehicle:write'],
-                    },
-                });
-                const closeElevation2 = user.elevatePermissions({
-                    businessModels: {
-                        [uuid2]: ['vehicle:write'],
-                    },
-                });
-                const { data: res1 } = await axios_1.default.post('http://localhost:8082');
-                closeElevation1();
-                const { data: res2 } = await axios_1.default.post('http://localhost:8082');
-                closeElevation2();
-                res.json([res1, res2]);
-            });
-        }, 8089);
-        const server2NumberOfPermissions = [];
-        const closeServer2 = await generateApp((app) => {
-            app.use((0, index_2.middleware)());
-            app.post('/', (req, res) => {
-                const user = (0, index_1.getUser)();
-                user.privatePermissions = {
-                    businessModels: {},
-                    fleets: {},
-                    demandSources: {},
-                };
-                server2NumberOfPermissions.push(Object.keys(user.permissions.businessModels).length);
-                server2TraceId = req.headers['x-trace-id'];
-                res.json({
-                    value: req.headers['x-af-header'],
-                    wkanda: req.headers['x-af-id'],
-                    addedPermissions: req.headers['x-af-elevated-permissions'],
-                });
-            });
-        }, 8082);
-        const { data: [res1, res2], headers } = await axios_1.default.get('http://localhost:8089', {
-            headers: {
-                'x-af-header': 'testHeader',
-                'x-af-id': 'my-wakanda-id',
-                'x-af-user-id': (0, uuid_1.v4)(),
-            },
-        });
-        closeServer1();
-        closeServer2();
-        expect(server2NumberOfPermissions).toEqual([2, 1]);
-        expect(headers['x-trace-id']).toEqual(server2TraceId);
-        expect(res1.value).toEqual('testHeader');
-        expect(res1.wkanda).toEqual('my-wakanda-id');
-        expect(JSON.parse(res1.addedPermissions).businessModels[uuid1]).toBeDefined();
-        expect(JSON.parse(res1.addedPermissions).businessModels[uuid2]).toBeDefined();
-        expect(JSON.parse(res2.addedPermissions).businessModels[uuid1]).not.toBeDefined();
-        expect(JSON.parse(res2.addedPermissions).businessModels[uuid2]).toBeDefined();
-    });
-    it('Should throw in case of invalid UUID', async () => {
-        let error = null;
-        (0, index_1.enableTracing)({
-            outbreakOptions: {
-                headersPrefix: 'x-af-',
-            },
-        });
-        const closeServer1 = await generateApp((app) => {
-            app.use((0, index_2.middleware)());
-            app.get('/', async (req, res) => {
-                const user = (0, index_1.getUser)();
-                try {
-                    const closeElevation1 = user.elevatePermissions({
-                        businessModels: {
-                            nnn: ['vehicle:write'],
-                        },
-                    });
-                    await axios_1.default.post('http://localhost:8082');
-                    closeElevation1();
-                }
-                catch (e) {
-                    error = e;
-                }
-                res.json({ status: 'ok' });
-            });
-        }, 8089);
-        await axios_1.default.get('http://localhost:8089', {
-            headers: {
-                'x-af-header': 'testHeader',
-                'x-af-id': 'my-wakanda-id',
-                'x-af-user-id': (0, uuid_1.v4)(),
-            },
-        });
-        closeServer1();
-        expect(error.message).toEqual('Entity id on elevatePermissions is not a valid UUID, provided: nnn');
-    });
-    it('should correctly handle elevation of permissions and their reversion', async () => {
-        let capturedError = null;
-        // Snapshots to capture state after each step
-        let afterFirstElevationElevated = {
-            fleets: {},
-            businessModels: {},
-            demandSources: {},
-        };
-        let afterFirstElevationCombined = {
-            fleets: {},
-            businessModels: {},
-            demandSources: {},
-        };
-        let afterSecondElevationElevated = {
-            fleets: {},
-            businessModels: {},
-            demandSources: {},
-        };
-        let afterSecondElevationCombined = {
-            fleets: {},
-            businessModels: {},
-            demandSources: {},
-        };
-        let afterCloseSecondElevated = {
-            fleets: {},
-            businessModels: {},
-            demandSources: {},
-        };
-        let afterCloseSecondCombined = {
-            fleets: {},
-            businessModels: {},
-            demandSources: {},
-        };
-        let afterCloseFirstElevated = {
-            fleets: {},
-            businessModels: {},
-            demandSources: {},
-        };
-        let afterCloseFirstCombined = {
-            fleets: {},
-            businessModels: {},
-            demandSources: {},
-        };
-        (0, index_1.enableTracing)({
-            outbreakOptions: {
-                headersPrefix: 'x-af-',
-            },
-        });
-        const userId = (0, uuid_1.v4)();
-        // Generate UUIDs for test entities
-        const fleetUUID1 = (0, uuid_1.v4)();
-        const fleetUUID2 = (0, uuid_1.v4)();
-        const bmUUID1 = (0, uuid_1.v4)();
-        const dsUUID1 = (0, uuid_1.v4)();
-        const dsUUID2 = (0, uuid_1.v4)();
-        // Spin up a test server
-        const closeServer = await generateApp((app) => {
-            app.use((0, index_2.middleware)());
-            app.get('/', async (req, res) => {
-                try {
-                    const user = (0, index_1.getUser)();
-                    // Load base permissions (mocked)
-                    await user.getUserPermissions();
-                    // Now user.privatePermissions is set
-                    // 1. First Elevation
-                    const closeElevation1 = user.elevatePermissions({
-                        fleets: {
-                            [fleetUUID1]: ['readF1'],
-                        },
-                        businessModels: {
-                            [bmUUID1]: ['writeBM1'],
-                        },
-                        demandSources: {
-                            [dsUUID1]: ['readDS1'],
-                        },
-                    });
-                    // Capture elevated and combined permissions after first elevation
-                    afterFirstElevationElevated = user.elevatedPermissions;
-                    afterFirstElevationCombined = user.permissions; // Non-null assertion since privatePermissions is set
-                    // 2. Second Elevation
-                    const closeElevation2 = user.elevatePermissions({
-                        fleets: {
-                            [fleetUUID1]: ['manageF1'],
-                            [fleetUUID2]: ['createF2'], // New fleet
-                        },
-                        businessModels: {
-                            [bmUUID1]: ['writeBM2'], // Additional permission to existing business model
-                        },
-                        demandSources: {
-                            [dsUUID2]: ['readDS2', 'readDS2'], // New demand source with duplicate permissions
-                        },
-                    });
-                    // Capture elevated and combined permissions after second elevation
-                    afterSecondElevationElevated = user.elevatedPermissions;
-                    afterSecondElevationCombined = user.permissions;
-                    // 3. Close Second Elevation
-                    closeElevation2();
-                    afterCloseSecondElevated = user.elevatedPermissions;
-                    afterCloseSecondCombined = user.permissions;
-                    // 4. Close First Elevation
-                    closeElevation1();
-                    afterCloseFirstElevated = user.elevatedPermissions;
-                    afterCloseFirstCombined = user.permissions;
-                }
-                catch (e) {
-                    capturedError = e;
-                }
-                res.json({ status: 'ok' });
-            });
-        }, 8089);
-        // Trigger the test route
-        const response = await axios_1.default.get('http://localhost:8089', {
-            headers: {
-                'x-af-user-id': userId,
-            },
-        });
-        closeServer();
-        // Basic assertions
-        expect(response.status).toEqual(200);
-        expect(capturedError).toBeNull();
-        // ---------------------
-        // Assertions After First Elevation
-        // ---------------------
-        expect(afterFirstElevationElevated.fleets?.[fleetUUID1]).toEqual(expect.arrayContaining(['readF1']));
-        expect(afterFirstElevationElevated.businessModels?.[bmUUID1]).toEqual(expect.arrayContaining(['writeBM1']));
-        expect(afterFirstElevationElevated.demandSources?.[dsUUID1]).toEqual(expect.arrayContaining(['readDS1']));
-        expect(afterFirstElevationCombined.fleets?.[fleetUUID1]).toEqual(expect.arrayContaining(['readF1']));
-        expect(afterFirstElevationCombined.businessModels?.[bmUUID1]).toEqual(expect.arrayContaining(['writeBM1']));
-        expect(afterFirstElevationCombined.demandSources?.[dsUUID1]).toEqual(expect.arrayContaining(['readDS1']));
-        // ---------------------
-        // Assertions After Second Elevation
-        // ---------------------
-        expect(afterSecondElevationElevated.fleets?.[fleetUUID1]).toEqual(expect.arrayContaining(['readF1', 'manageF1']));
-        expect(afterSecondElevationElevated.fleets?.[fleetUUID2]).toEqual(expect.arrayContaining(['createF2']));
-        expect(afterSecondElevationElevated.businessModels?.[bmUUID1]).toEqual(expect.arrayContaining(['writeBM1', 'writeBM2']));
-        expect(afterSecondElevationElevated.demandSources?.[dsUUID2]).toEqual(expect.arrayContaining(['readDS2', 'readDS2']));
-        expect(afterSecondElevationCombined.fleets?.[fleetUUID1]).toEqual(expect.arrayContaining(['readF1', 'manageF1']));
-        expect(afterSecondElevationCombined.fleets?.[fleetUUID2]).toEqual(expect.arrayContaining(['createF2']));
-        expect(afterSecondElevationCombined.businessModels?.[bmUUID1]).toEqual(expect.arrayContaining(['writeBM1', 'writeBM2']));
-        expect(afterSecondElevationCombined.demandSources?.[dsUUID2]).toEqual(expect.arrayContaining(['readDS2', 'readDS2']));
-        // ---------------------
-        // Assertions After Closing Second Elevation
-        // ---------------------
-        expect(afterCloseSecondElevated.fleets?.[fleetUUID1]).toEqual(expect.arrayContaining(['readF1']));
-        expect(afterCloseSecondElevated.fleets?.[fleetUUID2]).toBeUndefined();
-        expect(afterCloseSecondElevated.businessModels?.[bmUUID1]).toEqual(expect.arrayContaining(['writeBM1']));
-        expect(afterCloseSecondElevated.demandSources?.[dsUUID1]).toEqual(expect.arrayContaining(['readDS1']));
-        expect(afterCloseSecondElevated.demandSources?.[dsUUID2]).toBeUndefined();
-        expect(afterCloseSecondCombined.fleets?.[fleetUUID1]).toEqual(expect.arrayContaining(['readF1']));
-        expect(afterCloseSecondCombined.fleets?.[fleetUUID2]).toBeUndefined();
-        expect(afterCloseSecondCombined.businessModels?.[bmUUID1]).toEqual(expect.arrayContaining(['writeBM1']));
-        expect(afterCloseSecondCombined.demandSources?.[dsUUID1]).toEqual(expect.arrayContaining(['readDS1']));
-        expect(afterCloseSecondCombined.demandSources?.[dsUUID2]).toBeUndefined();
-        // ---------------------
-        // Assertions After Closing First Elevation
-        // ---------------------
-        expect(afterCloseFirstElevated.fleets).toEqual({});
-        expect(afterCloseFirstElevated.businessModels).toEqual({});
-        expect(afterCloseFirstElevated.demandSources).toEqual({});
-        expect(afterCloseFirstCombined.fleets).toEqual({});
-        expect(afterCloseFirstCombined.businessModels).toEqual({});
-        expect(afterCloseFirstCombined.demandSources).toEqual({});
-    });
-});