near-protocol-rewards/dist/tests/unit/collectors/base.test.js

A transparent, metric-based rewards system for NEAR projects

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const base_1 = require("../../../src/collectors/base");
class TestCollector extends base_1.BaseCollector {
    async testWithRateLimit(fn) {
        return this.withRateLimit(fn);
    }
    testError(message, context) {
        this.error(message, context);
    }
}
describe('BaseCollector', () => {
    let logger;
    let rateLimiter;
    let collector;
    beforeEach(() => {
        logger = {
            error: jest.fn(),
        };
        rateLimiter = {
            acquire: jest.fn().mockResolvedValue(undefined),
            release: jest.fn().mockResolvedValue(undefined),
        };
        collector = new TestCollector(logger, rateLimiter);
    });
    describe('error', () => {
        it('should log an error message', () => {
            const message = 'Test error message';
            const context = { key: 'value' };
            collector.testError(message, context);
            expect(logger.error).toHaveBeenCalledWith(message, context);
        });
        it('should not throw if logger is undefined', () => {
            collector = new TestCollector(undefined, rateLimiter);
            expect(() => collector.testError('Test error message')).not.toThrow();
        });
    });
    describe('withRateLimit', () => {
        it('should call acquire and release on rateLimiter', async () => {
            const fn = jest.fn().mockResolvedValue('result');
            const result = await collector.testWithRateLimit(fn);
            expect(rateLimiter.acquire).toHaveBeenCalled();
            expect(rateLimiter.release).toHaveBeenCalled();
            expect(result).toBe('result');
        });
        it('should release rateLimiter if fn throws an error', async () => {
            const fn = jest.fn().mockRejectedValue(new Error('Test error'));
            await expect(collector.testWithRateLimit(fn)).rejects.toThrow('Test error');
            expect(rateLimiter.acquire).toHaveBeenCalled();
            expect(rateLimiter.release).toHaveBeenCalled();
        });
    });
});