opticedge-cloud-utils 1.1.21 → 1.1.23

package/dist/tests/pub.test.js

@@ -1,102 +0,0 @@
-"use strict";
-// tests/pub.test.ts
-jest.mock('@google-cloud/pubsub', () => {
-    const instances = [];
-    class PubSub {
-        constructor(opts) {
-            this.topics = new Map();
-            this.opts = opts;
-            instances.push(this);
-        }
-        topic(name) {
-            if (!this.topics.has(name)) {
-                const publishMessage = jest.fn(({ data }) => Promise.resolve(`${this.opts?.projectId}-${name}`));
-                this.topics.set(name, { publishMessage });
-            }
-            return this.topics.get(name);
-        }
-    }
-    return { PubSub, __instances: instances };
-});
-const path = '../src/pub';
-describe('publishMessage', () => {
-    beforeEach(() => {
-        // ensure fresh module state between tests
-        jest.resetModules();
-        // clear any existing mock instances array if present
-        try {
-            const mockPubsub = require('@google-cloud/pubsub');
-            if (mockPubsub && Array.isArray(mockPubsub.__instances)) {
-                mockPubsub.__instances.length = 0;
-            }
-        }
-        catch {
-            // ignore if not loaded yet
-        }
-    });
-    test('publishes and returns messageId, sends JSON buffer', async () => {
-        const mockPubsub = require('@google-cloud/pubsub');
-        const { publishMessage } = require(path);
-        const envelope = { hello: 'world' };
-        const msgId = await publishMessage('project-1', 'topic-a', envelope);
-        expect(msgId).toBe('project-1-topic-a');
-        const instance = mockPubsub.__instances[0];
-        expect(instance).toBeDefined();
-        const publishMock = instance.topics.get('topic-a').publishMessage;
-        expect(publishMock).toHaveBeenCalledTimes(1);
-        const callArg = publishMock.mock.calls[0][0];
-        expect(callArg).toHaveProperty('data');
-        expect(callArg.data.toString()).toBe(JSON.stringify(envelope));
-    });
-    test('throws on missing arguments', async () => {
-        const { publishMessage } = require(path);
-        await expect(publishMessage('', 't', {})).rejects.toThrow('projectId is required');
-        await expect(publishMessage('p', '', {})).rejects.toThrow('topicName is required');
-        await expect(publishMessage('p', 't', undefined)).rejects.toThrow('envelope is required');
-    });
-    test('caches one PubSub instance across multiple calls for the same project', async () => {
-        const mockPubsub = require('@google-cloud/pubsub');
-        const { publishMessage } = require(path);
-        await publishMessage('project-1', 'topic-x', { a: 1 });
-        await publishMessage('project-1', 'topic-x', { b: 2 });
-        const instances = mockPubsub.__instances;
-        expect(instances.length).toBe(1);
-        const publishMock = instances[0].topics.get('topic-x').publishMessage;
-        expect(publishMock).toHaveBeenCalledTimes(2);
-    });
-    test('reuses the same PubSub instance even when called with a different projectId', async () => {
-        const mockPubsub = require('@google-cloud/pubsub');
-        const { publishMessage } = require(path);
-        // first call creates instance with project-A
-        await publishMessage('project-A', 't1', { x: 1 });
-        // second call passes a different project id but module currently reuses the cached instance
-        await publishMessage('project-B', 't2', { y: 2 });
-        const instances = mockPubsub.__instances;
-        // because src/pub.ts caches a single PubSub instance, only one instance should exist
-        expect(instances.length).toBe(1);
-        // the created instance was constructed with the first project id
-        expect(instances[0].opts).toEqual({ projectId: 'project-A' });
-        // ensure both publishes were invoked on the same instance (different topics)
-        expect(instances[0].topics.get('t1').publishMessage).toHaveBeenCalledTimes(1);
-        expect(instances[0].topics.get('t2').publishMessage).toHaveBeenCalledTimes(1);
-    });
-    test('logs error and rethrows when publish fails', async () => {
-        const mockPubsub = require('@google-cloud/pubsub');
-        // Override the mock PubSub.topic to return a publishMessage that rejects
-        mockPubsub.PubSub.prototype.topic = function (name) {
-            if (!this.topics.has(name)) {
-                const publishMessage = jest.fn(() => Promise.reject(new Error('boom')));
-                this.topics.set(name, { publishMessage });
-            }
-            return this.topics.get(name);
-        };
-        const { publishMessage } = require(path);
-        const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-        await expect(publishMessage('project-err', 'topic-err', { fail: true })).rejects.toThrow('boom');
-        expect(consoleErrorSpy).toHaveBeenCalled();
-        const firstArg = consoleErrorSpy.mock.calls[0][0];
-        expect(typeof firstArg).toBe('string');
-        expect(firstArg).toContain('ERROR: publish failed:');
-        consoleErrorSpy.mockRestore();
-    });
-});

package/dist/tests/regex.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/regex.test.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// tests/regex.test.ts
-const regex_1 = require("../src/regex");
-describe('escapeForRegex', () => {
-    it('escapes regex special characters (including backslash)', () => {
-        const input = 'Pikachu.$^*+?()[]{}|\\';
-        const expected = 'Pikachu\\.\\$\\^\\*\\+\\?\\(\\)\\[\\]\\{\\}\\|\\\\';
-        expect((0, regex_1.escapeForRegex)(input)).toBe(expected);
-    });
-    it('replaces whitespace runs with \\s+ and escapes other metachars', () => {
-        const input = 'Charizard (Holo   Rare)'; // multiple spaces inside
-        const expected = 'Charizard\\s+\\(Holo\\s+Rare\\)';
-        expect((0, regex_1.escapeForRegex)(input)).toBe(expected);
-    });
-    it('leaves plain alphanumerics unchanged', () => {
-        const input = 'Charmander123';
-        expect((0, regex_1.escapeForRegex)(input)).toBe('Charmander123');
-    });
-    it('converts tabs and single spaces to \\s+ and escapes dots', () => {
-        const input = 'Lt. Surge\tPikachu';
-        const expected = 'Lt\\.\\s+Surge\\s+Pikachu';
-        expect((0, regex_1.escapeForRegex)(input)).toBe(expected);
-    });
-    it('truncates input when maxLength is passed', () => {
-        const long = 'a'.repeat(200);
-        // override maxLength to 50 for this test
-        expect((0, regex_1.escapeForRegex)(long, 50)).toBe('a'.repeat(50));
-    });
-    it('applies default cap of 100 characters when input is longer and contains no metachars', () => {
-        const long = 'b'.repeat(150);
-        const out = (0, regex_1.escapeForRegex)(long); // default cap = 100
-        expect(out).toBe('b'.repeat(100));
-        expect(out.length).toBe(100);
-    });
-    it('handles empty string', () => {
-        expect((0, regex_1.escapeForRegex)('')).toBe('');
-    });
-    // -----------------------------
-    // NEW: coverage for safeStr branch
-    // -----------------------------
-    it('handles undefined input (covers input ?? "")', () => {
-        // call with undefined; TypeScript may complain so cast to any in test
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        expect((0, regex_1.escapeForRegex)(undefined)).toBe('');
-    });
-    it('handles null input (covers input ?? "")', () => {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        expect((0, regex_1.escapeForRegex)(null)).toBe('');
-    });
-    it('coerces non-string input to string and escapes metachars if present', () => {
-        // number becomes "42"
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        expect((0, regex_1.escapeForRegex)(42)).toBe('42');
-        // object coerces to "[object Object]" and special chars will be escaped if present
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const objInput = { toString: () => 'X(1) Y' };
-        expect((0, regex_1.escapeForRegex)(objInput)).toBe('X\\(1\\)\\s+Y');
-    });
-});

package/dist/tests/retry.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/retry.test.js

@@ -1,339 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// tests/retry.test.ts
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const axios_1 = __importDefault(require("axios"));
-const src_1 = require("../src");
-describe('sleep()', () => {
-    const realAbortController = global.AbortController;
-    afterEach(() => {
-        // restore timers and AbortController if changed
-        jest.useRealTimers();
-        global.AbortController = realAbortController;
-        jest.clearAllMocks();
-    });
-    test('resolves after the specified delay', async () => {
-        jest.useFakeTimers();
-        const p = (0, src_1.sleep)(100);
-        // advance timers by the sleep duration
-        jest.advanceTimersByTime(100);
-        // allow the Promise microtask queue to run
-        await Promise.resolve();
-        await expect(p).resolves.toBeUndefined();
-    });
-    test('rejects immediately if signal is already aborted', async () => {
-        const ac = new AbortController();
-        ac.abort();
-        await expect((0, src_1.sleep)(50, ac.signal)).rejects.toThrow('Aborted');
-    });
-    test('rejects when aborted after scheduling', async () => {
-        jest.useFakeTimers();
-        const ac = new AbortController();
-        const p = (0, src_1.sleep)(1000, ac.signal);
-        // abort after the sleep has been scheduled but before timeout
-        ac.abort();
-        // allow the event-loop microtasks to run
-        await Promise.resolve();
-        await expect(p).rejects.toThrow('Aborted');
-        // advancing timers should not resolve the promise
-        jest.advanceTimersByTime(1000);
-        await Promise.resolve();
-        await expect(p).rejects.toThrow('Aborted');
-    });
-});
-describe('isRetryableDefault', () => {
-    test('returns false for falsy errors (covers `if (!err) return false`)', () => {
-        expect((0, src_1.isRetryableDefault)(null)).toBe(false);
-        expect((0, src_1.isRetryableDefault)(undefined)).toBe(false);
-        // Also check a falsy-but-not-nullish value is handled (should coerce to false at top)
-        expect((0, src_1.isRetryableDefault)(0)).toBe(false);
-    });
-    test('returns false for an object with no retryable properties', () => {
-        expect((0, src_1.isRetryableDefault)({})).toBe(false);
-        expect((0, src_1.isRetryableDefault)({ foo: 'bar' })).toBe(false);
-    });
-    test('matches message containing "timeout" (case-insensitive)', () => {
-        expect((0, src_1.isRetryableDefault)(new Error('Request timed out'))).toBe(true);
-        expect((0, src_1.isRetryableDefault)(new Error('TIMEOUT occurred'))).toBe(true);
-        expect((0, src_1.isRetryableDefault)({ message: 'this is a timeout error' })).toBe(true);
-    });
-    test('matches message containing "temporary"', () => {
-        expect((0, src_1.isRetryableDefault)(new Error('Temporary failure contacting host'))).toBe(true);
-        expect((0, src_1.isRetryableDefault)({ message: 'temporary issue' })).toBe(true);
-    });
-    test('matches message containing "unavailable"', () => {
-        expect((0, src_1.isRetryableDefault)(new Error('Service Unavailable'))).toBe(true);
-        expect((0, src_1.isRetryableDefault)({ message: 'unavailable resource' })).toBe(true);
-    });
-    test('matches message containing "econnreset" or "etimedout" (substrings, case-insensitive)', () => {
-        expect((0, src_1.isRetryableDefault)(new Error('ECONNRESET by peer'))).toBe(true);
-        expect((0, src_1.isRetryableDefault)(new Error('econnreset'))).toBe(true);
-        expect((0, src_1.isRetryableDefault)(new Error('ETIMEDOUT waiting for response'))).toBe(true);
-        expect((0, src_1.isRetryableDefault)({ message: 'some ETIMEDOUT occurred' })).toBe(true);
-    });
-    test('does not treat unrelated messages as retryable', () => {
-        expect((0, src_1.isRetryableDefault)(new Error('Bad request'))).toBe(false);
-        expect((0, src_1.isRetryableDefault)({ message: 'invalid parameter provided' })).toBe(false);
-    });
-    test('still returns true when message sits alongside other properties (defensive)', () => {
-        const errLike = {
-            code: undefined,
-            response: undefined,
-            message: 'temporary network hiccup'
-        };
-        expect((0, src_1.isRetryableDefault)(errLike)).toBe(true);
-    });
-});
-describe('isRetryableAxios()', () => {
-    // Helper to synthesize axios-like errors
-    function makeAxiosError(payload = {}) {
-        // minimal axios-style error: flag + response optionally
-        const err = new Error(payload.message ?? 'axios-err');
-        err.isAxiosError = true;
-        if (Object.prototype.hasOwnProperty.call(payload, 'response')) {
-            err.response = payload.response;
-        }
-        else if (payload.response === undefined && payload.noResponse) {
-            // explicit network/no-response: leave out response
-        }
-        if (payload.code)
-            err.code = payload.code;
-        if (payload.message)
-            err.message = payload.message;
-        return err;
-    }
-    test('returns false when err is falsy', () => {
-        expect((0, src_1.isRetryableAxios)(null)).toBe(false);
-        expect((0, src_1.isRetryableAxios)(undefined)).toBe(false);
-        // also check other falsy-ish values that shouldn't be considered retryable
-        expect((0, src_1.isRetryableAxios)(false)).toBe(false);
-        expect((0, src_1.isRetryableAxios)('')).toBe(false);
-    });
-    test('returns true for network/no-response axios errors', () => {
-        const networkErr = makeAxiosError({ noResponse: true });
-        expect(axios_1.default.isAxiosError(networkErr)).toBe(true); // sanity check
-        expect((0, src_1.isRetryableAxios)(networkErr)).toBe(true);
-    });
-    test('returns true for 500 server error', () => {
-        const serverErr = makeAxiosError({ response: { status: 500, data: {} } });
-        expect((0, src_1.isRetryableAxios)(serverErr)).toBe(true);
-    });
-    test('returns true for 503 server error', () => {
-        const serverErr = makeAxiosError({ response: { status: 503, data: {} } });
-        expect((0, src_1.isRetryableAxios)(serverErr)).toBe(true);
-    });
-    test('returns true for 429 rate limit', () => {
-        const rateErr = makeAxiosError({ response: { status: 429, data: {} } });
-        expect((0, src_1.isRetryableAxios)(rateErr)).toBe(true);
-    });
-    test('returns false for 400 client error (do not retry)', () => {
-        const badReq = makeAxiosError({ response: { status: 400, data: {} } });
-        expect((0, src_1.isRetryableAxios)(badReq)).toBe(false);
-    });
-    test('delegates to isRetryableDefault for non-axios errors', () => {
-        // make a network-style Node error that isRetryableDefault recognizes
-        const nodeErr = { code: 'ECONNRESET', message: 'socket closed' };
-        expect((0, src_1.isRetryableDefault)(nodeErr)).toBe(true); // sanity
-        expect((0, src_1.isRetryableAxios)(nodeErr)).toBe(true);
-    });
-    test('returns false for non-retryable non-axios error', () => {
-        const normalErr = new Error('something bad but not retryable');
-        // isRetryableDefault likely returns false for a plain Error w/o hint
-        expect((0, src_1.isRetryableDefault)(normalErr)).toBe(false);
-        expect((0, src_1.isRetryableAxios)(normalErr)).toBe(false);
-    });
-});
-describe('retry util', () => {
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    test('returns result when fn succeeds immediately', async () => {
-        const fn = jest.fn(async () => 'ok');
-        const res = await (0, src_1.retry)(fn, { retries: 3 });
-        expect(res).toBe('ok');
-        expect(fn).toHaveBeenCalledTimes(1);
-    });
-    test('retries on transient error and eventually succeeds; onRetry called expected times', async () => {
-        // fail twice with retryable error (gRPC code 14), then succeed
-        let calls = 0;
-        const fn = jest.fn(async () => {
-            calls++;
-            if (calls <= 2) {
-                const e = new Error('transient-gprc');
-                e.code = 14;
-                throw e;
-            }
-            return 'ok-after-retries';
-        });
-        const onRetry = jest.fn();
-        // Make delays zero by forcing Math.random to 0 so tests are deterministic and fast
-        const mathSpy = jest.spyOn(Math, 'random').mockReturnValue(0);
-        const res = await (0, src_1.retry)(fn, { retries: 5, baseDelayMs: 10, onRetry });
-        expect(res).toBe('ok-after-retries');
-        expect(fn).toHaveBeenCalledTimes(3);
-        // onRetry called for the 2 transient failures
-        expect(onRetry).toHaveBeenCalledTimes(2);
-        mathSpy.mockRestore();
-    });
-    test('non-retryable error is rethrown immediately', async () => {
-        const fn = jest.fn(async () => {
-            const e = new Error('bad request');
-            e.status = 400;
-            throw e;
-        });
-        await expect((0, src_1.retry)(fn, { retries: 3 })).rejects.toThrow('bad request');
-        expect(fn).toHaveBeenCalledTimes(1);
-    });
-    test('exhausts retries and throws final error preserving original', async () => {
-        const original = new Error('permanent transient-like');
-        original.code = 14; // make it retryable
-        const fn = jest.fn(async () => {
-            throw original;
-        });
-        // make delays 0 to run fast
-        jest.spyOn(Math, 'random').mockReturnValue(0);
-        await expect((0, src_1.retry)(fn, { retries: 2, baseDelayMs: 1 })).rejects.toHaveProperty('original', original);
-        // initial call + 2 retries = 3 attempts
-        expect(fn).toHaveBeenCalledTimes(3);
-    });
-    test('isRetryableDefault recognizes common shapes', () => {
-        const e1 = new Error('econnreset happened');
-        e1.code = 'ECONNRESET';
-        expect((0, src_1.isRetryableDefault)(e1)).toBe(true);
-        const e2 = new Error('http 500');
-        e2.response = { status: 500 };
-        expect((0, src_1.isRetryableDefault)(e2)).toBe(true);
-        const e3 = new Error('not retryable');
-        e3.status = 400;
-        expect((0, src_1.isRetryableDefault)(e3)).toBe(false);
-        const e4 = new Error('gRPC unavailable');
-        e4.code = 14;
-        expect((0, src_1.isRetryableDefault)(e4)).toBe(true);
-    });
-    test('abort signal aborts immediately when already aborted', async () => {
-        const controller = new AbortController();
-        controller.abort();
-        const fn = jest.fn(async () => 'should-not-run');
-        await expect((0, src_1.retry)(fn, { signal: controller.signal })).rejects.toThrow('Aborted');
-        // function should not be called at all because we check signal at loop start
-        expect(fn).toHaveBeenCalledTimes(0);
-    });
-    test('abort during wait causes rejection', async () => {
-        // Function will fail once (retryable), then retry -> sleep -> we abort during sleep.
-        let calls = 0;
-        const fn = jest.fn(async () => {
-            calls++;
-            if (calls === 1) {
-                const e = new Error('transient');
-                e.code = 14;
-                throw e;
-            }
-            return 'should-not-get-here';
-        });
-        // Make delay large so we can abort during sleep (but we will abort synchronously)
-        jest.spyOn(Math, 'random').mockReturnValue(1); // picks the max exp
-        const controller = new AbortController();
-        // Start the retry but abort immediately after allowing the utility to start.
-        // We do not await retry here yet; create a Promise and then abort and await
-        const p = (0, src_1.retry)(fn, { retries: 3, baseDelayMs: 200, signal: controller.signal });
-        // Abort immediately — this should cause the pending sleep to reject
-        controller.abort();
-        await expect(p).rejects.toThrow('Aborted');
-    });
-    test('abort during wait causes rejection and triggers onAbort (clears timeout)', async () => {
-        // Function will fail once (retryable), then retry -> sleep -> we abort during sleep.
-        let calls = 0;
-        const fn = jest.fn(async () => {
-            calls++;
-            if (calls === 1) {
-                const e = new Error('transient');
-                e.code = 14;
-                throw e;
-            }
-            return 'should-not-get-here';
-        });
-        // Make sure there is a non-zero delay so sleep schedules a timer
-        jest.spyOn(Math, 'random').mockReturnValue(0.5);
-        const controller = new AbortController();
-        // Start the retry (it will throw once, then call sleep)
-        const p = (0, src_1.retry)(fn, { retries: 3, baseDelayMs: 200, signal: controller.signal });
-        // Wait a tick so `sleep` has a chance to attach the abort listener and call setTimeout.
-        // Using setTimeout 0 (or small timeout) guarantees the timer and listener are attached.
-        await new Promise(resolve => setTimeout(resolve, 0));
-        // Now abort — this should call the onAbort handler inside sleep which clears the timeout
-        controller.abort();
-        await expect(p).rejects.toThrow('Aborted');
-        Math.random.mockRestore();
-    });
-    test('respects timeoutMs and breaks before waiting (covers timeout check)', async () => {
-        // Make the wrapped fn throw a retryable error once
-        const original = new Error('transient-timeout');
-        original.code = 14; // make it retryable via isRetryableDefault
-        const fn = jest.fn(async () => {
-            throw original;
-        });
-        // Force Math.random to 1 so delay === exp (max for that attempt)
-        const mathSpy = jest.spyOn(Math, 'random').mockReturnValue(1);
-        // Use a baseDelayMs larger than timeoutMs so elapsed + delay > timeoutMs triggers the "break"
-        await expect((0, src_1.retry)(fn, {
-            retries: 5,
-            baseDelayMs: 50, // exp for attempt 1 = 50
-            timeoutMs: 10 // 50 > 10 so we should break before sleeping
-        })).rejects.toHaveProperty('original', original);
-        // fn should only have been called once (no retry/sleep occurred)
-        expect(fn).toHaveBeenCalledTimes(1);
-        mathSpy.mockRestore();
-    });
-    test('omitted opts uses default retries and eventually succeeds', async () => {
-        // Fail twice with retryable error (gRPC code 14), then succeed
-        let calls = 0;
-        const fn = jest.fn(async () => {
-            calls++;
-            if (calls <= 2) {
-                const e = new Error('transient');
-                e.code = 14;
-                throw e;
-            }
-            return 'ok-defaults';
-        });
-        // Make delays deterministic & small (Math.random = 0 -> delay = 0)
-        jest.spyOn(Math, 'random').mockReturnValue(0);
-        const res = await (0, src_1.retry)(fn); // <- call WITHOUT opts to exercise default param
-        expect(res).toBe('ok-defaults');
-        // Called initial + 2 retries = 3 times
-        expect(fn).toHaveBeenCalledTimes(3);
-        Math.random.mockRestore();
-    });
-    test('omitted opts exhausts default retries (5 attempts total) and throws', async () => {
-        const original = new Error('always-transient');
-        original.code = 14; // make it retryable
-        const fn = jest.fn(async () => {
-            throw original;
-        });
-        // Make delays 0 so test runs fast
-        jest.spyOn(Math, 'random').mockReturnValue(0);
-        // Default retries is 4 -> total attempts = 5
-        await expect((0, src_1.retry)(fn)).rejects.toHaveProperty('original', original);
-        expect(fn).toHaveBeenCalledTimes(5);
-        Math.random.mockRestore();
-    });
-    test('final error message falls back to String(lastErr) when lastErr.message is undefined', async () => {
-        // original is a plain object (no .message)
-        const original = { code: 14, detail: 'plain-object-no-message' };
-        const fn = jest.fn(async () => {
-            throw original; // will be assigned to lastErr in retry()
-        });
-        // Make delays deterministic & fast
-        const mathSpy = jest.spyOn(Math, 'random').mockReturnValue(0);
-        // retries = 1 -> attempt will be 1 in finalErr message
-        await expect((0, src_1.retry)(fn, { retries: 1, baseDelayMs: 1 })).rejects.toMatchObject({
-            message: expect.stringContaining('[object Object]'),
-            // Ensure original error was preserved on the thrown final error
-            original
-        });
-        mathSpy.mockRestore();
-    });
-});

package/dist/tests/secrets.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/secrets.test.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const secrets_1 = require("../src/secrets");
-const secret_manager_1 = require("@google-cloud/secret-manager");
-jest.mock('@google-cloud/secret-manager');
-// Mock implementation
-const mockAccessSecretVersion = jest.fn();
-secret_manager_1.SecretManagerServiceClient.mockImplementation(() => ({
-    accessSecretVersion: mockAccessSecretVersion
-}));
-describe('getSecret', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('returns secret value as string', async () => {
-        mockAccessSecretVersion.mockResolvedValue([
-            {
-                payload: { data: Buffer.from('super-secret-value') }
-            }
-        ]);
-        const result = await (0, secrets_1.getSecret)('test-project', 'test-secret');
-        expect(result).toBe('super-secret-value');
-        expect(mockAccessSecretVersion).toHaveBeenCalledWith({
-            name: 'projects/test-project/secrets/test-secret/versions/latest'
-        });
-    });
-    it('throws if projectId is missing', async () => {
-        await expect((0, secrets_1.getSecret)('', 'secret')).rejects.toThrow('projectId is required');
-    });
-    it('throws if secretName is missing', async () => {
-        await expect((0, secrets_1.getSecret)('project', '')).rejects.toThrow('secretName is required');
-    });
-    it('returns empty string if payload or data is missing', async () => {
-        mockAccessSecretVersion.mockResolvedValue([{}]); // no payload
-        const result = await (0, secrets_1.getSecret)('project', 'secret');
-        expect(result).toBe('');
-    });
-});

package/dist/tests/task.test.d.ts

@@ -1 +0,0 @@
-export {};