@contrail/flexplm 1.7.7-alpha.99f62a7 → 1.7.7-alpha.c59ab5b

package/lib/util/flexplm-connect.spec.js

@@ -28,23 +28,6 @@ const createConfig = (overrides) => ({
     useDistinctRestEndPointForImages: false,
     ...overrides,
 });
-// Added for Session reuse - ET-390 - Starts
-const csrfBody = { items: [{ attributes: { nonce_key: 'CSRF_NONCE', nonce: 'n1' } }] };
-// Response with Set-Cookie support. setCookie = list of raw Set-Cookie header lines.
-const resp = (status, setCookie = [], json = csrfBody) => ({
-    status,
-    json: jest.fn().mockResolvedValue(json),
-    text: jest.fn().mockResolvedValue('error text'),
-    headers: { getSetCookie: () => setCookie, get: () => null },
-});
-let userCounter = 0;
-const uniqueUser = () => 'sess-user-' + (++userCounter);
-// Session options are nested: { flexplmConnect: { sessionReuse: { enabled, ... } } }
-const sessionConfig = (user, sessionReuse = { enabled: true }) => createConfig({ userName: () => user, flexplmConnect: { sessionReuse } });
-const fetchMock = () => global.fetch;
-const callHeaders = (i) => fetchMock().mock.calls[i][1].headers;
-const callMethod = (i) => fetchMock().mock.calls[i][1].method;
-// Added for Session reuse - ET-390 - Ends
 describe('FlexPLMConnect.getRequest', () => {
     it('should call default URL with urlContext when no params provided', async () => {
         const connect = new flexplm_connect_1.FlexPLMConnect(createConfig());
@@ -138,603 +121,3 @@ describe('FlexPLMConnect.sendRequest', () => {
         consoleInfoSpy.mockRestore();
     });
 });
-// Added for Session reuse - ET-390 - Starts
-describe('FlexPLMConnect session reuse', () => {
-    const payload = { id: '123' };
-    it('should capture JSESSIONID from the CSRF GET and send it on the POST', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1; Path=/; HttpOnly']))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        expect(fetchMock()).toHaveBeenCalledTimes(2);
-        expect(callHeaders(0).Cookie).toBeUndefined(); // first ever call: no cached session
-        expect(callHeaders(1).Cookie).toBe('JSESSIONID=abc.tomcat1');
-        expect(callHeaders(1).CSRF_NONCE).toBe('n1');
-    });
-    it('should reuse the cached session on the next event (new FlexPLMConnect instance)', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1; Path=/'])) // event 1 GET
-            .mockResolvedValueOnce(resp(200, [], {})) // event 1 POST
-            .mockResolvedValueOnce(resp(200, [])) // event 2 GET (valid session -> no Set-Cookie)
-            .mockResolvedValueOnce(resp(200, [], {})); // event 2 POST
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1'); // GET reuses it
-        expect(callHeaders(3).Cookie).toBe('JSESSIONID=abc.tomcat1'); // POST reuses it
-    });
-    it('should replace the cached session when Windchill answers the GET with a new Set-Cookie', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1; Path=/']))
-            .mockResolvedValueOnce(resp(200, [], {}))
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1; Path=/'])) // old one was stale -> new issued
-            .mockResolvedValueOnce(resp(200, [], {}))
-            .mockResolvedValueOnce(resp(200, []))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        const connect = () => new flexplm_connect_1.FlexPLMConnect(sessionConfig(u));
-        await connect().sendToFlexPLM(payload);
-        await connect().sendToFlexPLM(payload);
-        await connect().sendToFlexPLM(payload);
-        expect(callHeaders(2).Cookie).toBe('JSESSIONID=old.tomcat1'); // event 2 GET sent the old one
-        expect(callHeaders(3).Cookie).toBe('JSESSIONID=new.tomcat1'); // POST uses the replacement
-        expect(callHeaders(4).Cookie).toBe('JSESSIONID=new.tomcat1'); // event 3 GET sends the replacement
-    });
-    it('should retry once with a new session when the POST is rejected with 403', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1; Path=/'])) // GET
-            .mockResolvedValueOnce(resp(403, [], {})) // POST rejected
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1; Path=/'])) // GET again, fresh session
-            .mockResolvedValueOnce(resp(200, [], { ok: true })); // POST succeeds
-        const result = await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        expect(fetchMock()).toHaveBeenCalledTimes(4);
-        expect(callHeaders(2).Cookie).toBeUndefined(); // retry GET must NOT send the stale cookie
-        expect(callHeaders(3).Cookie).toBe('JSESSIONID=new.tomcat1');
-        expect(result.status).toBe(200);
-        expect(result.data).toEqual({ ok: true });
-    });
-    it('should also retry on 401', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
-            .mockResolvedValueOnce(resp(401, [], {}))
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        expect(fetchMock()).toHaveBeenCalledTimes(4);
-    });
-    it('should not loop: a second 403 after the retry is surfaced as an error', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
-            .mockResolvedValueOnce(resp(403, [], {}))
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1']))
-            .mockResolvedValueOnce(resp(403, [], {}));
-        await expect(new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload))
-            .rejects.toThrow('Error sending data to FlexPLM:status: 403');
-        expect(fetchMock()).toHaveBeenCalledTimes(4);
-    });
-    it('should not retry on non-auth errors such as 500 (event may already be processed)', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-            .mockResolvedValueOnce(resp(500, [], {}));
-        await expect(new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload))
-            .rejects.toThrow('Error sending data to FlexPLM:status: 500');
-        expect(fetchMock()).toHaveBeenCalledTimes(2);
-    });
-    it('should retry the csrf GET without a cookie when the cached session is rejected there', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1'])) // event 1 GET
-            .mockResolvedValueOnce(resp(200, [], {})) // event 1 POST
-            .mockResolvedValueOnce(resp(401, [])) // event 2 GET with cached cookie rejected
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1'])) // event 2 GET retry, no cookie
-            .mockResolvedValueOnce(resp(200, [], {})); // event 2 POST
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        expect(callHeaders(2).Cookie).toBe('JSESSIONID=old.tomcat1');
-        expect(callHeaders(3).Cookie).toBeUndefined();
-        expect(callHeaders(4).Cookie).toBe('JSESSIONID=new.tomcat1');
-    });
-    it('should expire the cached session after ttlSeconds', async () => {
-        const u = uniqueUser();
-        const realNow = Date.now();
-        const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(realNow);
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}))
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=def.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        const cfg = sessionConfig(u, { enabled: true, ttlSeconds: 1 });
-        await new flexplm_connect_1.FlexPLMConnect(cfg).sendToFlexPLM(payload);
-        nowSpy.mockReturnValue(realNow + 2000); // 2s later > 1s ttl
-        await new flexplm_connect_1.FlexPLMConnect(cfg).sendToFlexPLM(payload);
-        expect(callHeaders(2).Cookie).toBeUndefined(); // expired -> GET sends no cookie
-        expect(callHeaders(3).Cookie).toBe('JSESSIONID=def.tomcat1');
-        nowSpy.mockRestore();
-    });
-    it('should use the last JSESSIONID when several Set-Cookie lines are returned', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=first.tomcat1; Path=/', 'OTHER=x; Path=/', 'JSESSIONID=second.tomcat1; Path=/']))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        expect(callHeaders(1).Cookie).toBe('JSESSIONID=second.tomcat1');
-    });
-    it('should fall back to headers.get("set-cookie") when getSetCookie is not available', async () => {
-        const u = uniqueUser();
-        const legacy = {
-            status: 200,
-            json: jest.fn().mockResolvedValue(csrfBody),
-            text: jest.fn(),
-            headers: { get: (k) => (k.toLowerCase() === 'set-cookie' ? 'JSESSIONID=legacy.tomcat1; Path=/' : null) },
-        };
-        fetchMock().mockResolvedValueOnce(legacy).mockResolvedValueOnce(resp(200, [], {}));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        expect(callHeaders(1).Cookie).toBe('JSESSIONID=legacy.tomcat1');
-    });
-    it('should honour a custom cookieName', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['MYSESSION=zzz; Path=/', 'JSESSIONID=ignored; Path=/']))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: 'MYSESSION' })).sendToFlexPLM(payload);
-        expect(callHeaders(1).Cookie).toBe('MYSESSION=zzz');
-    });
-    it('should accept enabled as the string "true"', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: 'true' })).sendToFlexPLM(payload);
-        expect(callHeaders(1).Cookie).toBe('JSESSIONID=abc.tomcat1');
-    });
-    it('should evict expired sessions of other users when a new session is stored', async () => {
-        const userA = uniqueUser();
-        const userB = uniqueUser();
-        const realNow = Date.now();
-        const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(realNow);
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=a.tomcat1'])) // A GET
-            .mockResolvedValueOnce(resp(200, [], {})) // A POST
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=b.tomcat1'])) // B GET
-            .mockResolvedValueOnce(resp(200, [], {})) // B POST
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=a2.tomcat1'])) // A GET again
-            .mockResolvedValueOnce(resp(200, [], {}));
-        const cfg = (u) => sessionConfig(u, { enabled: true, ttlSeconds: 1 });
-        await new flexplm_connect_1.FlexPLMConnect(cfg(userA)).sendToFlexPLM(payload);
-        nowSpy.mockReturnValue(realNow + 2000); // A has expired
-        await new flexplm_connect_1.FlexPLMConnect(cfg(userB)).sendToFlexPLM(payload); // storing B sweeps A
-        nowSpy.mockReturnValue(realNow); // rewind: only a swept A has no entry left
-        await new flexplm_connect_1.FlexPLMConnect(cfg(userA)).sendToFlexPLM(payload);
-        expect(callHeaders(4).Cookie).toBeUndefined();
-        nowSpy.mockRestore();
-    });
-    it('should not hold more than the maximum number of cached sessions', async () => {
-        const first = uniqueUser();
-        fetchMock().mockImplementation(async () => resp(200, ['JSESSIONID=s.tomcat1']));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(first)).sendToFlexPLM(payload);
-        for (let i = 0; i < 100; i++) {
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(uniqueUser())).sendToFlexPLM(payload);
-        }
-        fetchMock().mockClear();
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(first)).sendToFlexPLM(payload);
-        expect(callHeaders(0).Cookie).toBeUndefined(); // oldest entry was evicted
-    });
-    it('should keep separate sessions per user', async () => {
-        const a = uniqueUser();
-        const b = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=aaa.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}))
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=bbb.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(a)).sendToFlexPLM(payload);
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(b)).sendToFlexPLM(payload);
-        expect(callHeaders(2).Cookie).toBeUndefined(); // user b must not see user a's cookie
-        expect(callHeaders(3).Cookie).toBe('JSESSIONID=bbb.tomcat1');
-    });
-    it('should never log the cookie value', async () => {
-        const isInfoOn = jest.spyOn(app_framework_1.Logger, 'isInfoOn').mockReturnValue(true);
-        const info = jest.spyOn(console, 'info').mockImplementation();
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=supersecret.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}))
-            .mockResolvedValueOnce(resp(200, []))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload);
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload); // 2nd event sends Cookie on GET and POST
-        const logged = info.mock.calls.map(c => String(c[0] ?? '')).join('\n');
-        expect(logged).toContain('"Cookie":"***masked***"');
-        expect(logged).not.toContain('supersecret');
-        isInfoOn.mockRestore();
-        info.mockRestore();
-    });
-    describe('static Cookie header', () => {
-        const withStatic = (user, staticHeaders, sessionReuse = { enabled: true }) => createConfig({ userName: () => user, flexplmConnect: { sessionReuse, staticHeaders } });
-        it('should keep other static cookies and replace only the managed one once a session is cached', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1; Path=/']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(withStatic(u, { Cookie: 'lb=abc; JSESSIONID=stale; theme=dark' })).sendToFlexPLM(payload);
-            expect(callHeaders(0).Cookie).toBe('lb=abc; theme=dark'); // cold: stale managed cookie dropped
-            expect(callHeaders(1).Cookie).toBe('lb=abc; theme=dark; JSESSIONID=new.tomcat1');
-        });
-        it('should send a single Cookie header when the static header name is lowercase', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1; Path=/']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(withStatic(u, { cookie: 'lb=abc' })).sendToFlexPLM(payload);
-            const postHeaders = callHeaders(1);
-            expect(Object.keys(postHeaders).filter(k => k.toLowerCase() === 'cookie')).toEqual(['Cookie']);
-            expect(postHeaders.Cookie).toBe('lb=abc; JSESSIONID=abc.tomcat1');
-        });
-        it('should send the static Cookie unchanged when session reuse is disabled', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1; Path=/']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(withStatic(u, { Cookie: 'lb=abc; JSESSIONID=static' }, { enabled: false })).sendToFlexPLM(payload);
-            expect(callHeaders(0).Cookie).toBe('lb=abc; JSESSIONID=static');
-            expect(callHeaders(1).Cookie).toBe('lb=abc; JSESSIONID=static');
-        });
-        it('should not resend a rejected static JSESSIONID on the fresh retry', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1; Path=/']))
-                .mockResolvedValueOnce(resp(403, [], {})) // POST rejected
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=fresh.tomcat1; Path=/'])) // fresh GET
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(withStatic(u, { Cookie: 'lb=abc; JSESSIONID=static' })).sendToFlexPLM(payload);
-            expect(callHeaders(2).Cookie).toBe('lb=abc'); // fresh GET carries no JSESSIONID
-            expect(callHeaders(3).Cookie).toBe('lb=abc; JSESSIONID=fresh.tomcat1');
-        });
-        it('should mask a lowercase static cookie header in logs', async () => {
-            const isInfoOn = jest.spyOn(app_framework_1.Logger, 'isInfoOn').mockReturnValue(true);
-            const info = jest.spyOn(console, 'info').mockImplementation();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(withStatic(uniqueUser(), { cookie: 'lb=topsecret' }, { enabled: false })).sendToFlexPLM(payload);
-            const logged = info.mock.calls.map(c => String(c[0] ?? '')).join('\n');
-            expect(logged).not.toContain('topsecret');
-            isInfoOn.mockRestore();
-            info.mockRestore();
-        });
-    });
-    describe('option normalisation', () => {
-        const rejectedOnceThenOk = (u, opts) => {
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
-                .mockResolvedValueOnce(resp(403, [], {}))
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            return new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, ...opts })).sendToFlexPLM(payload);
-        };
-        it.each([
-            ['a scalar number', 403],
-            ['a comma separated string', '401, 403'],
-            ['garbage (falls back to 401/403)', 'abc'],
-            ['an empty array (falls back to 401/403)', []],
-        ])('should not throw and still retry on 403 when retryStatuses is %s', async (_label, retryStatuses) => {
-            await rejectedOnceThenOk(uniqueUser(), { retryStatuses });
-            expect(fetchMock()).toHaveBeenCalledTimes(4);
-        });
-        it.each([['abc'], [0], [-5]])('should fall back to the 900s default when ttlSeconds is invalid (%p)', async (ttlSeconds) => {
-            const u = uniqueUser();
-            const realNow = Date.now();
-            const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(realNow);
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}))
-                .mockResolvedValueOnce(resp(200, []))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            const cfg = sessionConfig(u, { enabled: true, ttlSeconds });
-            await new flexplm_connect_1.FlexPLMConnect(cfg).sendToFlexPLM(payload);
-            nowSpy.mockReturnValue(realNow + 2000);
-            await new flexplm_connect_1.FlexPLMConnect(cfg).sendToFlexPLM(payload);
-            expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1');
-            nowSpy.mockRestore();
-        });
-        it('should fall back to JSESSIONID when cookieName is blank', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: '   ' })).sendToFlexPLM(payload);
-            expect(callHeaders(1).Cookie).toBe('JSESSIONID=abc.tomcat1');
-        });
-    });
-    describe('retryStatuses restricted to client-error statuses', () => {
-        const postFailsWith = async (status, retryStatuses) => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-                .mockResolvedValueOnce(resp(status, [], {}));
-            await expect(new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, retryStatuses })).sendToFlexPLM({ id: '1' }))
-                .rejects.toThrow('Error sending data to FlexPLM:status: ' + status);
-            expect(fetchMock()).toHaveBeenCalledTimes(2); // no retry
-        };
-        it.each([[500], ['500'], [[200, 500]]])('should ignore non-4xx retryStatuses (%p) and not retry a 500', async (retryStatuses) => {
-            await postFailsWith(500, retryStatuses);
-        });
-        it('should keep 4xx entries and drop others from a mixed retryStatuses list', async () => {
-            await postFailsWith(500, [401, 500]);
-        });
-        it('should not resend a successful event when retryStatuses is configured as 200', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, retryStatuses: 200 })).sendToFlexPLM({ id: '1' });
-            expect(fetchMock()).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('session cache key includes session options', () => {
-        it('should not share a cached cookie between different cookieNames for the same user', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['AAA=a1; Path=/']))
-                .mockResolvedValueOnce(resp(200, [], {}))
-                .mockResolvedValueOnce(resp(200, ['BBB=b1; Path=/']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: 'AAA' })).sendToFlexPLM({ id: '1' });
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: 'BBB' })).sendToFlexPLM({ id: '1' });
-            expect(callHeaders(2).Cookie).toBeUndefined(); // BBB config must not pick up the AAA session
-            expect(callHeaders(3).Cookie).toBe('BBB=b1');
-        });
-        it('should not share a cached session between different ttlSeconds for the same user', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=short.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}))
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=long.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, ttlSeconds: 1 })).sendToFlexPLM({ id: '1' });
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, ttlSeconds: 900 })).sendToFlexPLM({ id: '1' });
-            expect(callHeaders(2).Cookie).toBeUndefined();
-            expect(callHeaders(3).Cookie).toBe('JSESSIONID=long.tomcat1');
-        });
-    });
-    describe('rejected response disposal', () => {
-        const withBody = (r) => Object.assign(r, { body: { cancel: jest.fn().mockResolvedValue(undefined) } });
-        it('should cancel the body of a POST rejected with 403 before retrying', async () => {
-            const u = uniqueUser();
-            const rejected = withBody(resp(403, [], {}));
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
-                .mockResolvedValueOnce(rejected)
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM({ id: '1' });
-            expect(rejected.body.cancel).toHaveBeenCalledTimes(1);
-        });
-        it('should cancel the body of a CSRF GET rejected with the cached cookie before retrying', async () => {
-            const u = uniqueUser();
-            const rejected = withBody(resp(401, []));
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}))
-                .mockResolvedValueOnce(rejected)
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM({ id: '1' });
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM({ id: '1' });
-            expect(rejected.body.cancel).toHaveBeenCalledTimes(1);
-        });
-        it('should cancel the body of a getRequest rejected with the cached cookie before retrying', async () => {
-            const u = uniqueUser();
-            const rejected = withBody(resp(401, []));
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}))
-                .mockResolvedValueOnce(rejected)
-                .mockResolvedValueOnce(resp(200, [], { items: [] }));
-            const connect = new flexplm_connect_1.FlexPLMConnect(sessionConfig(u));
-            await connect.sendToFlexPLM({ id: '1' });
-            await connect.getRequest();
-            expect(rejected.body.cancel).toHaveBeenCalledTimes(1);
-        });
-        it('should still retry when cancelling the body throws', async () => {
-            const u = uniqueUser();
-            const rejected = resp(403, [], {});
-            rejected.body = { cancel: jest.fn().mockRejectedValue(new Error('locked')) };
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
-                .mockResolvedValueOnce(rejected)
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM({ id: '1' });
-            expect(fetchMock()).toHaveBeenCalledTimes(4);
-        });
-    });
-    describe('cookie names containing regex metacharacters', () => {
-        it('should extract a cookie whose name contains "+"', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['SID+=abc; Path=/']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: 'SID+' })).sendToFlexPLM(payload);
-            expect(callHeaders(1).Cookie).toBe('SID+=abc');
-        });
-        it('should treat "." literally and not match a look-alike cookie', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['AxB=wrong; Path=/']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: 'A.B' })).sendToFlexPLM(payload);
-            expect(callHeaders(1).Cookie).toBeUndefined();
-        });
-    });
-    describe('concurrent session acquisition', () => {
-        const flush = () => new Promise(r => setImmediate(r));
-        const isColdGet = (call) => call[1].method === 'GET' && !call[1].headers.Cookie;
-        it('should not let a late response using an older cookie roll back a refreshed session', async () => {
-            const u = uniqueUser();
-            const cfg = () => sessionConfig(u);
-            // seed the cache with 'old'
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=old']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(cfg()).sendToFlexPLM(payload);
-            let lateGetsSeen = 0;
-            let releaseLate;
-            const lateGate = new Promise(r => { releaseLate = r; });
-            fetchMock().mockReset();
-            fetchMock().mockImplementation(async (_url, opts) => {
-                const cookie = opts.headers.Cookie;
-                if (opts.method === 'GET' && cookie === 'JSESSIONID=old') {
-                    if (++lateGetsSeen === 1)
-                        return resp(403, []); // event A: old rejected
-                    await lateGate; // event B: slow 200, no Set-Cookie
-                    return resp(200, []);
-                }
-                if (opts.method === 'GET' && !cookie)
-                    return resp(200, ['JSESSIONID=new']); // A's fresh acquisition
-                if (opts.method === 'GET')
-                    return resp(200, []);
-                return resp(200, [], {});
-            });
-            const a = new flexplm_connect_1.FlexPLMConnect(cfg()).sendToFlexPLM(payload);
-            const b = new flexplm_connect_1.FlexPLMConnect(cfg()).sendToFlexPLM(payload);
-            await a;
-            releaseLate();
-            await b;
-            fetchMock().mockClear();
-            await new flexplm_connect_1.FlexPLMConnect(cfg()).getCSRF();
-            expect(callHeaders(0).Cookie).toBe('JSESSIONID=new'); // B must not have stored 'old' again
-        });
-        it('should share one session across concurrent events on a cold cache', async () => {
-            const u = uniqueUser();
-            let release;
-            const gate = new Promise(r => { release = r; });
-            fetchMock().mockImplementation(async (_url, opts) => {
-                if (opts.method === 'GET' && !opts.headers.Cookie) {
-                    await gate;
-                    return resp(200, ['JSESSIONID=abc.tomcat1']);
-                }
-                return resp(200, []);
-            });
-            const all = Promise.all([1, 2, 3].map(() => new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).getCSRF()));
-            await flush();
-            expect(fetchMock()).toHaveBeenCalledTimes(1); // the other two are waiting for the first acquisition
-            release();
-            const results = await all;
-            expect(fetchMock().mock.calls.filter(isColdGet)).toHaveLength(1);
-            results.forEach(r => expect(r.sessionCookie).toBe('abc.tomcat1'));
-        });
-        it('should not make a waiter inherit the failure of the first acquisition', async () => {
-            const u = uniqueUser();
-            let release;
-            const gate = new Promise(r => { release = r; });
-            fetchMock()
-                .mockImplementationOnce(async () => { await gate; return resp(500, []); })
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']));
-            const first = new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).getCSRF();
-            const firstResult = first.catch(e => e);
-            const second = new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).getCSRF();
-            await flush();
-            release();
-            expect(await firstResult).toBeInstanceOf(Error);
-            expect((await second).sessionCookie).toBe('abc.tomcat1');
-        });
-        it('should create only one replacement session for parallel events rejected with 403', async () => {
-            const u = uniqueUser();
-            fetchMock().mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).getCSRF(); // prime the cache with the old session
-            fetchMock().mockReset();
-            fetchMock().mockImplementation(async (_url, opts) => {
-                const cookie = opts.headers.Cookie;
-                if (opts.method === 'POST')
-                    return cookie === 'JSESSIONID=new.tomcat1' ? resp(200, [], {}) : resp(403, [], {});
-                if (!cookie)
-                    return resp(200, ['JSESSIONID=new.tomcat1']);
-                return resp(200, []);
-            });
-            await Promise.all([1, 2, 3].map(() => new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload)));
-            expect(fetchMock().mock.calls.filter(isColdGet)).toHaveLength(1);
-        });
-    });
-});
-describe('FlexPLMConnect session reuse - feature disabled (default)', () => {
-    const payload = { id: '123' };
-    it('should send no Cookie header and make exactly one GET + one POST', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1'])) // Set-Cookie present but must be ignored
-            .mockResolvedValueOnce(resp(200, [], {}))
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=def.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        const cfg = createConfig({ userName: () => u }); // no flexplmConnect at all
-        await new flexplm_connect_1.FlexPLMConnect(cfg).sendToFlexPLM(payload);
-        await new flexplm_connect_1.FlexPLMConnect(cfg).sendToFlexPLM(payload);
-        for (let i = 0; i < 4; i++) {
-            expect(callHeaders(i).Cookie).toBeUndefined();
-        }
-    });
-    it('should not retry on 403 (behaves exactly as before)', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200))
-            .mockResolvedValueOnce(resp(403, [], {}));
-        await expect(new flexplm_connect_1.FlexPLMConnect(createConfig({ userName: () => u })).sendToFlexPLM(payload))
-            .rejects.toThrow('Error sending data to FlexPLM:status: 403');
-        expect(fetchMock()).toHaveBeenCalledTimes(2);
-    });
-    it('should behave the same as not configured when enabled is false', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}));
-        await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: false })).sendToFlexPLM(payload);
-        expect(callHeaders(1).Cookie).toBeUndefined();
-    });
-});
-describe('FlexPLMConnect.getRequest session reuse', () => {
-    it('should send the cached cookie on image/GET requests', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1'])) // csrf GET primes the cache
-            .mockResolvedValueOnce(resp(200, [], {})) // POST
-            .mockResolvedValueOnce(resp(200, [], { items: [] })); // getRequest
-        const connect = new flexplm_connect_1.FlexPLMConnect(sessionConfig(u));
-        await connect.sendToFlexPLM({ id: '1' });
-        await connect.getRequest();
-        expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1');
-    });
-    it('should retry once without the cookie when the cached session is rejected on getRequest', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}))
-            .mockResolvedValueOnce(resp(401, [])) // getRequest with cached cookie
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1'], { items: [] })); // retry, no cookie
-        const connect = new flexplm_connect_1.FlexPLMConnect(sessionConfig(u));
-        await connect.sendToFlexPLM({ id: '1' });
-        await connect.getRequest();
-        expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1');
-        expect(callHeaders(3).Cookie).toBeUndefined();
-    });
-    it('should not re-store the rejected cookie when the retry issues no Set-Cookie', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=stale.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}))
-            .mockResolvedValueOnce(resp(401, [])) // getRequest with the cached cookie
-            .mockResolvedValueOnce(resp(200, [], { items: [] })) // retry succeeds, no Set-Cookie
-            .mockResolvedValueOnce(resp(200, [], { items: [] })); // next getRequest
-        const connect = new flexplm_connect_1.FlexPLMConnect(sessionConfig(u));
-        await connect.sendToFlexPLM({ id: '1' });
-        await connect.getRequest();
-        await connect.getRequest();
-        expect(callHeaders(3).Cookie).toBeUndefined();
-        expect(callHeaders(4).Cookie).toBeUndefined(); // stale cookie must not be sent again
-    });
-});
-// Added for Session reuse - ET-390 - Ends

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.7.7-alpha.99f62a7",
+  "version": "1.7.7-alpha.c59ab5b",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",