store-platform/tests/utils/requestTemplate.test.js

import { test, describe } from 'node:test';
import assert from 'node:assert';
import {
    getEntityByDateRangeForOrganisationId,
    getEntityByDateRange,
    syncEntity,
    writeOrUpdateEntity,
    createEntity,
    updateEntity,
    deleteEntity,
    readEntity
} from '../../../src/utils/requestTemplate.js';

describe('requestTemplate', () => {
    describe('getEntityByDateRangeForOrganisationId', () => {
        test('должна быть функцией', () => {
            assert.strictEqual(typeof getEntityByDateRangeForOrganisationId, 'function');
        });

        test('должна возвращать Promise', () => {
            const mockPool = {
                connect: async () => ({
                    // eslint-disable-next-line camelcase
                    query: async () => ({ rows: [{ total_count: '0' }] }),
                    release: () => {}
                })
            };

            const result = getEntityByDateRangeForOrganisationId(
                1,
                '2024-01-01',
                '2024-12-31',
                1,
                30,
                'test_table',
                mockPool
            );

            assert(result instanceof Promise);
        });

        test('должна возвращать правильную структуру данных с пагинацией', async () => {
            const mockPool = {
                connect: async () => ({
                    query: async (query, params) => {
                        if (query.includes('COUNT(*)')) {
                            return { rows: [{ total_count: '50' }] };
                        }
                        return { rows: [{ id: 1, name: 'test' }] };
                    },
                    release: () => {}
                })
            };

            const result = await getEntityByDateRangeForOrganisationId(
                1,
                '2024-01-01',
                '2024-12-31',
                1,
                30,
                'test_table',
                mockPool
            );

            assert.ok(result);
            assert.strictEqual(result.currentPage, 1);
            assert.strictEqual(result.size, 30);
            assert.ok(Array.isArray(result.pageList));
            assert.ok(typeof result.pages === 'number');
        });

        test('должна обрабатывать ошибки подключения к БД', async () => {
            const mockPool = {
                connect: async () => {
                    throw new Error('Connection failed');
                }
            };

            await assert.rejects(
                async () => await getEntityByDateRangeForOrganisationId(
                    1,
                    '2024-01-01',
                    '2024-12-31',
                    1,
                    30,
                    'test_table',
                    mockPool
                ),
                /Connection failed/
            );
        });
    });

    describe('getEntityByDateRange', () => {
        test('должна быть функцией', () => {
            assert.strictEqual(typeof getEntityByDateRange, 'function');
        });

        test('должна возвращать Promise', () => {
            const mockPool = {
                connect: async () => ({
                    // eslint-disable-next-line camelcase
                    query: async () => ({ rows: [{ total_count: '0' }] }),
                    release: () => {}
                })
            };

            const result = getEntityByDateRange(
                '2024-01-01',
                '2024-12-31',
                1,
                30,
                'test_table',
                mockPool
            );

            assert(result instanceof Promise);
        });

        test('должна возвращать правильную структуру данных', async () => {
            const mockPool = {
                connect: async () => ({
                    query: async (query, params) => {
                        if (query.includes('COUNT(*)')) {
                            return { rows: [{ total_count: '25' }] };
                        }
                        return { rows: [{ id: 1, name: 'test' }] };
                    },
                    release: () => {}
                })
            };

            const result = await getEntityByDateRange(
                '2024-01-01',
                '2024-12-31',
                1,
                30,
                'test_table',
                mockPool
            );

            assert.ok(result);
            assert.strictEqual(result.currentPage, 1);
            assert.ok(Array.isArray(result.pageList));
        });
    });

    describe('syncEntity', () => {
        test('должна быть функцией', () => {
            assert.strictEqual(typeof syncEntity, 'function');
        });

        test('должна возвращать Promise', () => {
            const mockPool = {
                connect: async () => ({
                    query: async () => ({ rows: [] }),
                    release: () => {}
                })
            };

            const result = syncEntity(
                [{ id: 1, name: 'test' }],
                'test_table',
                'id',
                mockPool
            );

            assert(result instanceof Promise);
        });

        test('должна синхронизировать данные', async () => {
            let queryCount = 0;
            const mockPool = {
                connect: async () => ({
                    query: async (query) => {
                        queryCount++;
                        if (query.includes('SELECT')) {
                            return { rows: [] };
                        }
                        return { rows: [{ id: 1 }] };
                    },
                    release: () => {}
                })
            };

            const result = await syncEntity(
                [{ id: 1, name: 'test' }],
                'test_table',
                'id',
                mockPool
            );

            assert.ok(result);
            assert.ok(queryCount > 0);
        });
    });

    describe('writeOrUpdateEntity', () => {
        test('должна быть функцией', () => {
            assert.strictEqual(typeof writeOrUpdateEntity, 'function');
        });

        test('должна возвращать Promise', () => {
            const mockPool = {
                connect: async () => ({
                    query: async () => ({ rows: [{ id: 1 }] }),
                    release: () => {}
                })
            };

            const result = writeOrUpdateEntity(
                { id: 1, name: 'test' },
                'test_table',
                'id',
                mockPool
            );

            assert(result instanceof Promise);
        });
    });

    describe('createEntity', () => {
        test('должна быть функцией', () => {
            assert.strictEqual(typeof createEntity, 'function');
        });

        test('должна возвращать Promise', () => {
            const mockPool = {
                connect: async () => ({
                    query: async () => ({ rows: [{ id: 1 }] }),
                    release: () => {}
                })
            };

            const result = createEntity(
                { name: 'test' },
                'test_table',
                mockPool
            );

            assert(result instanceof Promise);
        });

        test('должна создавать новую запись', async () => {
            const mockPool = {
                connect: async () => ({
                    query: async (query) => {
                        assert.ok(query.includes('INSERT INTO'));
                        assert.ok(query.includes('test_table'));
                        return { rows: [{ id: 1, name: 'test' }] };
                    },
                    release: () => {}
                })
            };

            const result = await createEntity(
                { name: 'test' },
                'test_table',
                mockPool
            );

            assert.ok(result);
            assert.strictEqual(result.id, 1);
        });
    });

    describe('updateEntity', () => {
        test('должна быть функцией', () => {
            assert.strictEqual(typeof updateEntity, 'function');
        });

        test('должна возвращать Promise', () => {
            const mockPool = {
                connect: async () => ({
                    query: async () => ({ rows: [{ id: 1 }] }),
                    release: () => {}
                })
            };

            const result = updateEntity(
                { name: 'updated' },
                1,
                'test_table',
                'id',
                mockPool
            );

            assert(result instanceof Promise);
        });

        test('должна обновлять запись', async () => {
            const mockPool = {
                connect: async () => ({
                    query: async (query) => {
                        assert.ok(query.includes('UPDATE'));
                        assert.ok(query.includes('test_table'));
                        return { rows: [{ id: 1, name: 'updated' }] };
                    },
                    release: () => {}
                })
            };

            const result = await updateEntity(
                { name: 'updated' },
                1,
                'test_table',
                'id',
                mockPool
            );

            assert.ok(result);
            assert.strictEqual(result.name, 'updated');
        });
    });

    describe('deleteEntity', () => {
        test('должна быть функцией', () => {
            assert.strictEqual(typeof deleteEntity, 'function');
        });

        test('должна возвращать Promise', () => {
            const mockPool = {
                connect: async () => ({
                    query: async () => ({ rows: [{ id: 1 }] }),
                    release: () => {}
                })
            };

            const result = deleteEntity(
                1,
                'test_table',
                'id',
                mockPool
            );

            assert(result instanceof Promise);
        });

        test('должна удалять запись', async () => {
            const mockPool = {
                connect: async () => ({
                    query: async (query) => {
                        assert.ok(query.includes('DELETE FROM'));
                        assert.ok(query.includes('test_table'));
                        return { rows: [{ id: 1 }] };
                    },
                    release: () => {}
                })
            };

            const result = await deleteEntity(
                1,
                'test_table',
                'id',
                mockPool
            );

            assert.ok(result);
        });
    });

    describe('readEntity', () => {
        test('должна быть функцией', () => {
            assert.strictEqual(typeof readEntity, 'function');
        });

        test('должна возвращать Promise', () => {
            const mockPool = {
                connect: async () => ({
                    query: async () => ({ rows: [{ id: 1, name: 'test' }] }),
                    release: () => {}
                })
            };

            const result = readEntity(
                {},
                'test_table',
                1,
                mockPool
            );

            assert(result instanceof Promise);
        });

        test('должна читать запись из таблицы', async () => {
            const mockPool = {
                connect: async () => ({
                    query: async (query) => {
                        assert.ok(query.includes('SELECT * FROM'));
                        assert.ok(query.includes('test_table'));
                        return { rows: [{ id: 1, name: 'test' }] };
                    },
                    release: () => {}
                })
            };

            const result = await readEntity(
                {},
                'test_table',
                1,
                mockPool
            );

            assert.ok(result);
            assert.strictEqual(result.id, 1);
            assert.strictEqual(result.name, 'test');
        });
    });
});