keez-invoicing 1.1.5

package/dist/tests/additional-coverage.test.js

@@ -0,0 +1,351 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const nock = require("nock");
+const keezApi_1 = require("../src/keezApi");
+const authorise_1 = require("../src/api/authorise");
+const cancel_1 = require("../src/api/invoices/cancel");
+const delete_1 = require("../src/api/invoices/delete");
+const downloadPdf_1 = require("../src/api/invoices/downloadPdf");
+const update_1 = require("../src/api/invoices/update");
+const submitEfactura_1 = require("../src/api/invoices/submitEfactura");
+const validate_1 = require("../src/api/invoices/validate");
+const view_1 = require("../src/api/invoices/view");
+const getAll_1 = require("../src/api/invoices/getAll");
+const sendMail_1 = require("../src/api/invoices/sendMail");
+const create_1 = require("../src/api/items/create");
+const getAll_2 = require("../src/api/items/getAll");
+const getById_1 = require("../src/api/items/getById");
+const update_2 = require("../src/api/items/update");
+const patch_1 = require("../src/api/items/patch");
+const paymentType_1 = require("../src/config/paymentType");
+const measureUnit_1 = require("../src/config/measureUnit");
+const KeezError_1 = require("../src/errors/KeezError");
+const baseDomain = 'https://staging.keez.ro';
+const clientEid = 'test-client-eid';
+describe('Additional Coverage Tests', () => {
+    afterEach(() => {
+        nock.cleanAll();
+    });
+    describe('KeezApi getInvoiceByExternalId through class', () => {
+        let keezApi;
+        beforeAll(() => {
+            keezApi = new keezApi_1.KeezApi({
+                application_id: 'test-app-id',
+                client_eid: clientEid,
+                secret: 'test-secret',
+                live: false,
+            });
+        });
+        it('should get invoice by external ID through KeezApi class', async () => {
+            nock(baseDomain)
+                .post('/idp/connect/token')
+                .reply(200, {
+                access_token: 'test-token',
+                expires_in: 3600,
+                token_type: 'Bearer',
+                scope: 'public-api',
+            });
+            const mockInvoice = {
+                currencyCode: 'RON',
+                discountGrossValue: 0,
+                discountNetValue: 0,
+                discountVatValue: 0,
+                discountValueOnNet: false,
+                exciseAmount: 0,
+                documentDate: 20230423,
+                dueDate: 20230430,
+                exchangeRate: 1,
+                grossAmount: 119,
+                netAmount: 100,
+                number: 1,
+                originalNetAmount: 100,
+                originalVatAmount: 19,
+                partner: {
+                    addressDetails: 'Test Address',
+                    cityName: 'Bucharest',
+                    countryCode: 'RO',
+                    countryName: 'Romania',
+                    countyCode: 'RO.B',
+                    countyName: 'Bucharest',
+                    identificationNumber: '12345678',
+                    isLegalPerson: false,
+                    partnerName: 'Test Partner',
+                },
+                invoiceDetails: [
+                    {
+                        discountGrossValue: 0,
+                        discountNetValue: 0,
+                        discountVatValue: 0,
+                        discountValueOnNet: false,
+                        grossAmount: 119,
+                        itemCode: 'ITEM-001',
+                        itemDescription: 'Test Item',
+                        itemExternalId: 'item-ext-1',
+                        itemName: 'Test Item Name',
+                        measureUnitId: 1,
+                        netAmount: 100,
+                        originalNetAmount: 100,
+                        originalVatAmount: 19,
+                        quantity: 1,
+                        unMeasureUnit: 'buc',
+                        unVatCategory: 'S',
+                        unVatExemptionReason: '',
+                        unitPrice: 100,
+                        vatAmount: 19,
+                        vatPercent: 19,
+                        exciseAmount: 0,
+                    },
+                ],
+                paymentTypeId: 3,
+                referenceCurrencyCode: 'RON',
+                series: 'PDI',
+                status: 'draft',
+                vatAmount: 19,
+                vatOnCollection: false,
+            };
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/invoices/inv-123`)
+                .reply(200, mockInvoice);
+            const result = await keezApi.getInvoiceByExternalId('inv-123');
+            expect(result.grossAmount).toBe(119);
+            expect(result.partner.partnerName).toBe('Test Partner');
+        });
+    });
+    describe('Network Error Handling (axiosError.message fallback)', () => {
+        it('should handle network error in apiGenerateToken', async () => {
+            nock(baseDomain)
+                .post('/idp/connect/token')
+                .replyWithError('Network Error');
+            await expect((0, authorise_1.apiGenerateToken)({
+                baseDomain,
+                appId: 'test-app-id',
+                apiSecret: 'test-secret',
+            })).rejects.toThrow(KeezError_1.KeezAuthError);
+        });
+        it('should handle network error in apiCancelInvoice', async () => {
+            nock(baseDomain)
+                .post(`/api/v1.0/public-api/${clientEid}/invoices/canceled`)
+                .replyWithError('Connection refused');
+            await expect((0, cancel_1.apiCancelInvoice)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                invoiceId: 'inv-123',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiDeleteInvoice', async () => {
+            nock(baseDomain)
+                .delete(`/api/v1.0/public-api/${clientEid}/invoices`)
+                .replyWithError('Connection timeout');
+            await expect((0, delete_1.apiDeleteInvoice)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                invoiceId: 'inv-123',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiDownloadInvoicePdf', async () => {
+            nock(baseDomain)
+                .get('/api/v1.0/public-api/invoices/inv-123/pdf')
+                .replyWithError('DNS resolution failed');
+            await expect((0, downloadPdf_1.apiDownloadInvoicePdf)({
+                baseDomain,
+                appId: 'test-app-id',
+                bearerToken: 'test-token',
+                invoiceId: 'inv-123',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiUpdateInvoice', async () => {
+            nock(baseDomain)
+                .put(`/api/v1.0/public-api/${clientEid}/invoices/inv-123`)
+                .replyWithError('Socket hang up');
+            await expect((0, update_1.apiUpdateInvoice)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                invoiceId: 'inv-123',
+                invoice: {
+                    series: 'INV',
+                    documentDate: 20230101,
+                    dueDate: 20230115,
+                    currencyCode: 'RON',
+                    paymentType: paymentType_1.PaymentType.BANK_TRANSFER,
+                    partner: {
+                        isLegalPerson: false,
+                        partnerName: 'Test Partner',
+                        identificationNumber: '123456',
+                        countryCode: 'RO',
+                        countryName: 'Romania',
+                        countyCode: 'B',
+                        countyName: 'Bucuresti',
+                        cityName: 'Bucuresti',
+                        addressDetails: 'Test Address',
+                    },
+                    items: [
+                        {
+                            itemExternalId: 'item-1',
+                            measureUnitId: 1,
+                            quantity: 1,
+                            unitPrice: 100,
+                        },
+                    ],
+                },
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiSubmitEfactura', async () => {
+            nock(baseDomain)
+                .post(`/api/v1.0/public-api/${clientEid}/invoices/efactura/submitted`)
+                .replyWithError('ECONNRESET');
+            await expect((0, submitEfactura_1.apiSubmitEfactura)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                invoiceId: 'inv-123',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiValidateInvoice', async () => {
+            nock(baseDomain)
+                .post(`/api/v1.0/public-api/${clientEid}/invoices/valid`)
+                .replyWithError('ETIMEDOUT');
+            await expect((0, validate_1.apiValidateInvoice)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                invoiceId: 'inv-123',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiGetInvoiceByExternalId', async () => {
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/invoices/inv-123`)
+                .replyWithError('ENOTFOUND');
+            await expect((0, view_1.apiGetInvoiceByExternalId)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                invoiceId: 'inv-123',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiGetAllInvoices', async () => {
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/invoices`)
+                .replyWithError('EHOSTUNREACH');
+            await expect((0, getAll_1.apiGetAllInvoices)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiSendInvoice', async () => {
+            nock(baseDomain)
+                .post('/api/v1.0/public-api/invoices/delivery')
+                .replyWithError('ECONNREFUSED');
+            await expect((0, sendMail_1.apiSendInvoice)({
+                baseDomain,
+                appId: 'test-app-id',
+                bearerToken: 'test-token',
+                clientMail: 'test@example.com',
+                invoiceId: 'inv-123',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiCreateItem', async () => {
+            nock(baseDomain)
+                .post(`/api/v1.0/public-api/${clientEid}/items`)
+                .replyWithError('Network Error');
+            await expect((0, create_1.apiCreateItem)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                item: {
+                    itemName: 'Test Item',
+                    measureUnitId: measureUnit_1.MeasureUnit.PIECE,
+                    unitPrice: 100,
+                    vatPercent: 19,
+                },
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiGetAllItems', async () => {
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/items`)
+                .replyWithError('Connection failed');
+            await expect((0, getAll_2.apiGetAllItems)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiGetItemById', async () => {
+            nock(baseDomain)
+                .get(`/api/v1.0/public-api/${clientEid}/items/item-123`)
+                .replyWithError('Request timeout');
+            await expect((0, getById_1.apiGetItemById)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                itemId: 'item-123',
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiUpdateItem', async () => {
+            nock(baseDomain)
+                .put(`/api/v1.0/public-api/${clientEid}/items/item-123`)
+                .replyWithError('Socket closed');
+            await expect((0, update_2.apiUpdateItem)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                itemId: 'item-123',
+                item: {
+                    itemName: 'Updated Item',
+                    measureUnitId: measureUnit_1.MeasureUnit.PIECE,
+                    unitPrice: 150,
+                    vatPercent: 19,
+                },
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+        it('should handle network error in apiPatchItem', async () => {
+            nock(baseDomain)
+                .patch(`/api/v1.0/public-api/${clientEid}/items/item-123`)
+                .replyWithError('Peer reset connection');
+            await expect((0, patch_1.apiPatchItem)({
+                baseDomain,
+                appId: 'test-app-id',
+                appClientId: clientEid,
+                bearerToken: 'test-token',
+                itemId: 'item-123',
+                item: {
+                    unitPrice: 200,
+                },
+            })).rejects.toThrow(KeezError_1.KeezApiError);
+        });
+    });
+    describe('Logger branch coverage', () => {
+        it('should use debug log level when DEBUG env is set', async () => {
+            // This test is more for completeness - the logger branch is based on LOG_LEVEL env
+            nock(baseDomain)
+                .post('/idp/connect/token')
+                .reply(200, {
+                access_token: 'test-token',
+                expires_in: 3600,
+                token_type: 'Bearer',
+                scope: 'public-api',
+            });
+            const result = await (0, authorise_1.apiGenerateToken)({
+                baseDomain,
+                appId: 'test-app-id',
+                apiSecret: 'test-secret',
+            });
+            expect(result.access_token).toBe('test-token');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"additional-coverage.test.js","sourceRoot":"","sources":["../../tests/additional-coverage.test.ts"],"names":[],"mappings":"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","sourcesContent":["import nock = require('nock');\nimport { KeezApi } from '@/keezApi';\nimport { apiGenerateToken } from '@/api/authorise';\nimport { apiCancelInvoice } from '@/api/invoices/cancel';\nimport { apiDeleteInvoice } from '@/api/invoices/delete';\nimport { apiDownloadInvoicePdf } from '@/api/invoices/downloadPdf';\nimport { apiUpdateInvoice } from '@/api/invoices/update';\nimport { apiSubmitEfactura } from '@/api/invoices/submitEfactura';\nimport { apiValidateInvoice } from '@/api/invoices/validate';\nimport { apiGetInvoiceByExternalId } from '@/api/invoices/view';\nimport { apiGetAllInvoices } from '@/api/invoices/getAll';\nimport { apiSendInvoice } from '@/api/invoices/sendMail';\nimport { apiCreateItem } from '@/api/items/create';\nimport { apiGetAllItems } from '@/api/items/getAll';\nimport { apiGetItemById } from '@/api/items/getById';\nimport { apiUpdateItem } from '@/api/items/update';\nimport { apiPatchItem } from '@/api/items/patch';\nimport { PaymentType } from '@/config/paymentType';\nimport { MeasureUnit } from '@/config/measureUnit';\nimport { KeezAuthError, KeezApiError } from '@/errors/KeezError';\n\nconst baseDomain = 'https://staging.keez.ro';\nconst clientEid = 'test-client-eid';\n\ndescribe('Additional Coverage Tests', () => {\n    afterEach(() => {\n        nock.cleanAll();\n    });\n\n    describe('KeezApi getInvoiceByExternalId through class', () => {\n        let keezApi: KeezApi;\n\n        beforeAll(() => {\n            keezApi = new KeezApi({\n                application_id: 'test-app-id',\n                client_eid: clientEid,\n                secret: 'test-secret',\n                live: false,\n            });\n        });\n\n        it('should get invoice by external ID through KeezApi class', async () => {\n            nock(baseDomain)\n                .post('/idp/connect/token')\n                .reply(200, {\n                    access_token: 'test-token',\n                    expires_in: 3600,\n                    token_type: 'Bearer',\n                    scope: 'public-api',\n                });\n\n            const mockInvoice = {\n                currencyCode: 'RON',\n                discountGrossValue: 0,\n                discountNetValue: 0,\n                discountVatValue: 0,\n                discountValueOnNet: false,\n                exciseAmount: 0,\n                documentDate: 20230423,\n                dueDate: 20230430,\n                exchangeRate: 1,\n                grossAmount: 119,\n                netAmount: 100,\n                number: 1,\n                originalNetAmount: 100,\n                originalVatAmount: 19,\n                partner: {\n                    addressDetails: 'Test Address',\n                    cityName: 'Bucharest',\n                    countryCode: 'RO',\n                    countryName: 'Romania',\n                    countyCode: 'RO.B',\n                    countyName: 'Bucharest',\n                    identificationNumber: '12345678',\n                    isLegalPerson: false,\n                    partnerName: 'Test Partner',\n                },\n                invoiceDetails: [\n                    {\n                        discountGrossValue: 0,\n                        discountNetValue: 0,\n                        discountVatValue: 0,\n                        discountValueOnNet: false,\n                        grossAmount: 119,\n                        itemCode: 'ITEM-001',\n                        itemDescription: 'Test Item',\n                        itemExternalId: 'item-ext-1',\n                        itemName: 'Test Item Name',\n                        measureUnitId: 1,\n                        netAmount: 100,\n                        originalNetAmount: 100,\n                        originalVatAmount: 19,\n                        quantity: 1,\n                        unMeasureUnit: 'buc',\n                        unVatCategory: 'S',\n                        unVatExemptionReason: '',\n                        unitPrice: 100,\n                        vatAmount: 19,\n                        vatPercent: 19,\n                        exciseAmount: 0,\n                    },\n                ],\n                paymentTypeId: 3,\n                referenceCurrencyCode: 'RON',\n                series: 'PDI',\n                status: 'draft',\n                vatAmount: 19,\n                vatOnCollection: false,\n            };\n\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/invoices/inv-123`)\n                .reply(200, mockInvoice);\n\n            const result = await keezApi.getInvoiceByExternalId('inv-123');\n            expect(result.grossAmount).toBe(119);\n            expect(result.partner.partnerName).toBe('Test Partner');\n        });\n    });\n\n    describe('Network Error Handling (axiosError.message fallback)', () => {\n        it('should handle network error in apiGenerateToken', async () => {\n            nock(baseDomain)\n                .post('/idp/connect/token')\n                .replyWithError('Network Error');\n\n            await expect(\n                apiGenerateToken({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    apiSecret: 'test-secret',\n                })\n            ).rejects.toThrow(KeezAuthError);\n        });\n\n        it('should handle network error in apiCancelInvoice', async () => {\n            nock(baseDomain)\n                .post(`/api/v1.0/public-api/${clientEid}/invoices/canceled`)\n                .replyWithError('Connection refused');\n\n            await expect(\n                apiCancelInvoice({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    invoiceId: 'inv-123',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiDeleteInvoice', async () => {\n            nock(baseDomain)\n                .delete(`/api/v1.0/public-api/${clientEid}/invoices`)\n                .replyWithError('Connection timeout');\n\n            await expect(\n                apiDeleteInvoice({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    invoiceId: 'inv-123',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiDownloadInvoicePdf', async () => {\n            nock(baseDomain)\n                .get('/api/v1.0/public-api/invoices/inv-123/pdf')\n                .replyWithError('DNS resolution failed');\n\n            await expect(\n                apiDownloadInvoicePdf({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    bearerToken: 'test-token',\n                    invoiceId: 'inv-123',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiUpdateInvoice', async () => {\n            nock(baseDomain)\n                .put(`/api/v1.0/public-api/${clientEid}/invoices/inv-123`)\n                .replyWithError('Socket hang up');\n\n            await expect(\n                apiUpdateInvoice({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    invoiceId: 'inv-123',\n                    invoice: {\n                        series: 'INV',\n                        documentDate: 20230101,\n                        dueDate: 20230115,\n                        currencyCode: 'RON',\n                        paymentType: PaymentType.BANK_TRANSFER,\n                        partner: {\n                            isLegalPerson: false,\n                            partnerName: 'Test Partner',\n                            identificationNumber: '123456',\n                            countryCode: 'RO',\n                            countryName: 'Romania',\n                            countyCode: 'B',\n                            countyName: 'Bucuresti',\n                            cityName: 'Bucuresti',\n                            addressDetails: 'Test Address',\n                        },\n                        items: [\n                            {\n                                itemExternalId: 'item-1',\n                                measureUnitId: 1,\n                                quantity: 1,\n                                unitPrice: 100,\n                            },\n                        ],\n                    },\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiSubmitEfactura', async () => {\n            nock(baseDomain)\n                .post(`/api/v1.0/public-api/${clientEid}/invoices/efactura/submitted`)\n                .replyWithError('ECONNRESET');\n\n            await expect(\n                apiSubmitEfactura({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    invoiceId: 'inv-123',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiValidateInvoice', async () => {\n            nock(baseDomain)\n                .post(`/api/v1.0/public-api/${clientEid}/invoices/valid`)\n                .replyWithError('ETIMEDOUT');\n\n            await expect(\n                apiValidateInvoice({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    invoiceId: 'inv-123',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiGetInvoiceByExternalId', async () => {\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/invoices/inv-123`)\n                .replyWithError('ENOTFOUND');\n\n            await expect(\n                apiGetInvoiceByExternalId({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    invoiceId: 'inv-123',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiGetAllInvoices', async () => {\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/invoices`)\n                .replyWithError('EHOSTUNREACH');\n\n            await expect(\n                apiGetAllInvoices({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiSendInvoice', async () => {\n            nock(baseDomain)\n                .post('/api/v1.0/public-api/invoices/delivery')\n                .replyWithError('ECONNREFUSED');\n\n            await expect(\n                apiSendInvoice({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    bearerToken: 'test-token',\n                    clientMail: 'test@example.com',\n                    invoiceId: 'inv-123',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiCreateItem', async () => {\n            nock(baseDomain)\n                .post(`/api/v1.0/public-api/${clientEid}/items`)\n                .replyWithError('Network Error');\n\n            await expect(\n                apiCreateItem({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    item: {\n                        itemName: 'Test Item',\n                        measureUnitId: MeasureUnit.PIECE,\n                        unitPrice: 100,\n                        vatPercent: 19,\n                    },\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiGetAllItems', async () => {\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/items`)\n                .replyWithError('Connection failed');\n\n            await expect(\n                apiGetAllItems({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiGetItemById', async () => {\n            nock(baseDomain)\n                .get(`/api/v1.0/public-api/${clientEid}/items/item-123`)\n                .replyWithError('Request timeout');\n\n            await expect(\n                apiGetItemById({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    itemId: 'item-123',\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiUpdateItem', async () => {\n            nock(baseDomain)\n                .put(`/api/v1.0/public-api/${clientEid}/items/item-123`)\n                .replyWithError('Socket closed');\n\n            await expect(\n                apiUpdateItem({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    itemId: 'item-123',\n                    item: {\n                        itemName: 'Updated Item',\n                        measureUnitId: MeasureUnit.PIECE,\n                        unitPrice: 150,\n                        vatPercent: 19,\n                    },\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n\n        it('should handle network error in apiPatchItem', async () => {\n            nock(baseDomain)\n                .patch(`/api/v1.0/public-api/${clientEid}/items/item-123`)\n                .replyWithError('Peer reset connection');\n\n            await expect(\n                apiPatchItem({\n                    baseDomain,\n                    appId: 'test-app-id',\n                    appClientId: clientEid,\n                    bearerToken: 'test-token',\n                    itemId: 'item-123',\n                    item: {\n                        unitPrice: 200,\n                    },\n                })\n            ).rejects.toThrow(KeezApiError);\n        });\n    });\n\n    describe('Logger branch coverage', () => {\n        it('should use debug log level when DEBUG env is set', async () => {\n            // This test is more for completeness - the logger branch is based on LOG_LEVEL env\n            nock(baseDomain)\n                .post('/idp/connect/token')\n                .reply(200, {\n                    access_token: 'test-token',\n                    expires_in: 3600,\n                    token_type: 'Bearer',\n                    scope: 'public-api',\n                });\n\n            const result = await apiGenerateToken({\n                baseDomain,\n                appId: 'test-app-id',\n                apiSecret: 'test-secret',\n            });\n\n            expect(result.access_token).toBe('test-token');\n        });\n    });\n});\n"]}