@chift/chift-nodejs 1.0.17 → 1.0.18

package/test/modules/consumer.test.ts

@@ -1,68 +0,0 @@
-import { beforeAll, expect, test } from '@jest/globals';
-import * as chift from '../../src/index';
-import * as dotenv from 'dotenv';
-import { components } from '../../src/types/public-api/schema';
-dotenv.config();
-
-const client = new chift.API({
-    baseUrl: process.env.CHIFT_BACKBONE_API,
-    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
-    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
-    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
-});
-
-const consumerName = 'test consumer 2';
-const email = 'support@chift.eu';
-const redirect_url = 'https://chift.eu';
-
-let syncConsumer: any;
-let consumer: any;
-let connection: any;
-
-beforeAll(async () => {
-    consumer = await client.Consumers.createConsumer({
-        email,
-        redirect_url,
-        name: consumerName,
-    });
-    syncConsumer = await client.Consumers.getConsumerById(
-        process.env.CHIFT_SYNC_CONSUMER_ID as string
-    );
-});
-
-test('createConnection', async () => {
-    const body = { integrationid: 1000, name: 'odoo test sdk' };
-    const result = await consumer.createConnection(body);
-    expect(result).toHaveProperty('url', expect.any(String));
-});
-
-let connections: components['schemas']['backbone_api__app__routers__connections__ConnectionItem'][];
-
-test('getConnections', async () => {
-    connections = await syncConsumer.getConnections();
-    expect(connections).toBeInstanceOf(Array);
-});
-
-test.skip('updateConnection', async () => {
-    const updatedConnection = await syncConsumer.updateConnection(connections[0]?.connectionid, {
-        name: 'updated connection name',
-    });
-    expect(updatedConnection).toHaveProperty('name', 'updated connection name');
-});
-
-test.skip('deleteConnection', async () => {
-    await consumer.deleteConnection(connection.connectionId);
-});
-
-test('getSyncUrl', async () => {
-    const result = await syncConsumer.getSyncUrl({
-        syncid: process.env.CHIFT_TEST_SYNC_ID as string,
-        integrationids: [],
-    });
-    expect(result).toHaveProperty('url', expect.any(String));
-});
-
-test('getSyncData', async () => {
-    const syncData = await syncConsumer.getSyncData(process.env.CHIFT_TEST_SYNC_ID as string);
-    expect(syncData).toBeTruthy();
-});

package/test/modules/consumers.test.ts

@@ -1,85 +0,0 @@
-import { beforeAll, expect, test } from '@jest/globals';
-import * as chift from '../../src/index';
-import axios from 'axios';
-import * as dotenv from 'dotenv';
-
-dotenv.config();
-
-const client = new chift.API({
-    baseUrl: process.env.CHIFT_BACKBONE_API,
-    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
-    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
-    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
-});
-
-const consumerName = 'test consumer';
-const email = 'support@chift.eu';
-const redirect_url = 'https://chift.eu';
-
-let consumer: any;
-
-beforeAll(async () => {
-    consumer = await client.Consumers.createConsumer({
-        email,
-        redirect_url,
-        name: consumerName,
-    });
-});
-
-test('createConsumer', async () => {
-    expect(consumer).toHaveProperty('consumerId');
-    expect(consumer).toHaveProperty('getConnections');
-    expect(consumer).toHaveProperty('createConnection');
-    expect(consumer).toHaveProperty('updateConnection');
-    expect(consumer).toHaveProperty('deleteConnection');
-    expect(consumer).toHaveProperty('getSyncUrl');
-    expect(consumer).toHaveProperty('name', consumerName);
-    expect(consumer).toHaveProperty('redirect_url', redirect_url);
-    expect(consumer).toHaveProperty('email', email);
-    expect(consumer).toHaveProperty('pos');
-    expect(consumer).toHaveProperty('accounting');
-    expect(consumer).toHaveProperty('invoicing');
-    expect(consumer).toHaveProperty('ecommerce');
-    expect(consumer).toHaveProperty('custom');
-});
-
-test('getConsumers', async () => {
-    const consumers = await client.Consumers.getConsumers();
-    expect(consumers).toBeInstanceOf(Array);
-});
-
-test('getConsumersByName', async () => {
-    const consumersWithName = await client.Consumers.getConsumersByName(consumerName);
-    expect(consumersWithName).toBeInstanceOf(Array);
-    expect(consumersWithName.some((consumer: any) => consumer.name.includes(consumerName))).toBe(
-        true
-    );
-});
-
-test('getConsumerById', async () => {
-    const consumerWithId = await client.Consumers.getConsumerById(consumer.consumerId);
-    expect(consumerWithId).toHaveProperty('consumerId', consumer.consumerId);
-});
-
-test('updateConsumerById', async () => {
-    const updatedName = 'updated test consumer';
-    const updatedConsumer = await client.Consumers.updateConsumerById(consumer.consumerId, {
-        name: updatedName,
-    });
-    expect(updatedConsumer).toHaveProperty('name', updatedName);
-});
-
-test('deleteConsumerById', async () => {
-    expect.assertions(1);
-    try {
-        await client.Consumers.deleteConsumerById(consumer.consumerId);
-        await client.Consumers.getConsumerById(consumer.consumerId);
-    } catch (e: unknown) {
-        if (axios.isAxiosError(e)) {
-            expect(e.message).toMatch('Request failed with status code 404');
-            return;
-        }
-
-        throw e;
-    }
-});

package/test/modules/ecommerce.test.ts

@@ -1,213 +0,0 @@
-import { beforeAll, expect, test } from '@jest/globals';
-import * as chift from '../../src/index';
-import * as dotenv from 'dotenv';
-import { components } from '../../src/types/public-api/schema';
-dotenv.config();
-
-const client = new chift.API({
-    baseUrl: process.env.CHIFT_BACKBONE_API,
-    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
-    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
-    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
-});
-
-const consumerId = process.env.CHIFT_ECOMMERCE_CONSUMER_ID as string;
-
-let consumer: any;
-beforeAll(async () => {
-    consumer = await client.Consumers.getConsumerById(consumerId);
-});
-
-let customers: components['schemas']['CommerceCustomerItem'][];
-test('getCustomers', async () => {
-    customers = await consumer.ecommerce.getCustomers();
-    expect(customers).toBeInstanceOf(Array);
-    expect(customers.length).toBeGreaterThan(0);
-    expect(customers[0]).toHaveProperty('id', expect.any(String));
-});
-
-let products: components['schemas']['backbone_api__app__routers__commerce__ProductItem'][];
-test('getProducts', async () => {
-    products = await consumer.ecommerce.getProducts();
-    expect(products).toBeInstanceOf(Array);
-    expect(products.length).toBeGreaterThan(0);
-    expect(products[0]).toHaveProperty('id', expect.any(String));
-});
-
-test('getCustomer', async () => {
-    const customer = await consumer.ecommerce.getCustomer(customers[0].id);
-    expect(customer).toHaveProperty('id', customers[0].id);
-    expect(customer).toHaveProperty('first_name');
-    expect(customer).toHaveProperty('last_name');
-    expect(customer).toHaveProperty('phone');
-    expect(customer).toHaveProperty('email');
-    expect(customer).toHaveProperty('language');
-    expect(customer).toHaveProperty('internal_notes');
-    expect(customer).toHaveProperty('currency');
-    expect(customer).toHaveProperty('addresses');
-    expect(customer).toHaveProperty('created_on');
-});
-
-test('getProduct', async () => {
-    const product = await consumer.ecommerce.getProduct(products[0].id);
-    expect(product).toBeTruthy();
-    expect(product).toHaveProperty('id', products[0].id);
-    expect(product).toHaveProperty('name', expect.any(String));
-    expect(product).toHaveProperty('description');
-    expect(product).toHaveProperty('description_html');
-    expect(product).toHaveProperty('categories');
-    expect(product).toHaveProperty('created_on');
-    expect(product).toHaveProperty('variants');
-    expect(product).toHaveProperty('status');
-    expect(product).toHaveProperty('common_attributes');
-    expect(product).toHaveProperty('variant_attributes_options');
-    expect(product).toHaveProperty('common_images');
-});
-
-let productVariant: components['schemas']['VariantItem'];
-test.skip('getProductVariantById', async () => {
-    if (!products?.length) {
-        throw new Error('No product to test');
-    }
-
-    if (!products[0].variants.length) {
-        throw new Error('No product variant to test');
-    }
-
-    productVariant = await consumer.ecommerce.getProductVariantById(products[0].variants[0].id);
-    expect(productVariant).toBeTruthy();
-    expect(productVariant).toHaveProperty('id', expect.any(String));
-});
-
-let locations: components['schemas']['CommerceLocationItem'][];
-test('getLocations', async () => {
-    locations = await consumer.ecommerce.getLocations();
-    expect(locations).toBeInstanceOf(Array);
-    expect(locations.length).toBeGreaterThan(0);
-    expect(locations[0]).toHaveProperty('id', expect.any(String));
-    expect(locations[0]).toHaveProperty('name', expect.any(String));
-});
-
-test.skip('updateAvailableQuantity', async () => {
-    if (!productVariant) {
-        throw new Error('No product variant found to update available quantity');
-    }
-
-    if (!locations?.length) {
-        throw new Error('No location found to update available quantity');
-    }
-
-    const product = await consumer.ecommerce.updateAvailableQuantity(productVariant.id, {
-        location_id: locations[0].id,
-        available_quantity: 1,
-    });
-    expect(product).toBeTruthy();
-    expect(product).toHaveProperty('available_quantity', expect.any(Number));
-});
-
-// TODO: Fix create order test
-test.skip('createOrder', async () => {
-    const order = await consumer.ecommerce.createOrder({
-        customer: {
-            email: 'test@test.com',
-        },
-        billing_address: {
-            first_name: 'Test',
-            last_name: 'Test',
-            street: 'Test',
-            number: '1',
-            city: 'Test',
-            country: 'BE',
-        },
-        shipping_address: {
-            first_name: 'Test',
-            last_name: 'Test',
-            street: 'Test',
-            number: '1',
-            city: 'Test',
-            country: 'BE',
-        },
-        currency: 'EUR',
-        lines: [
-            {
-                variant_id: '1',
-                quantity: 1,
-                tax_rate: 21.0,
-                unit_price: 10.0,
-            },
-        ],
-        payment_method: 'bank-transfer',
-    });
-    expect(order).toBeTruthy();
-    expect(order).toHaveProperty('id', expect.any(String));
-});
-
-let orders: components['schemas']['OrderItemOut'][];
-test('getOrders', async () => {
-    orders = await consumer.ecommerce.getOrders({
-        date_from: '2023-01-08',
-        date_to: '2023-01-01',
-    });
-    expect(orders).toBeInstanceOf(Array);
-});
-
-test.skip('getOrder', async () => {
-    if (!orders?.length) {
-        throw new Error('No orders found to test getOrder');
-    }
-
-    const order = await consumer.ecommerce.getOrder(orders[0].id);
-    expect(order).toBeTruthy();
-    expect(order).toHaveProperty('id', expect.any(String));
-    expect(order).toHaveProperty('order_number');
-    expect(order).toHaveProperty('billing_address');
-    expect(order).toHaveProperty('shipping_address');
-    expect(order).toHaveProperty('created_on');
-    expect(order).toHaveProperty('confirmed_on');
-    expect(order).toHaveProperty('cancelled_on');
-    expect(order).toHaveProperty('status', expect.any(String));
-    expect(order).toHaveProperty('discount_amount', expect.any(Number));
-    expect(order).toHaveProperty('untaxed_amount_without_fees', expect.any(Number));
-    expect(order).toHaveProperty('tax_amount_without_fees', expect.any(Number));
-    expect(order).toHaveProperty('total_without_fees', expect.any(Number));
-    expect(order).toHaveProperty('untaxed_amount', expect.any(Number));
-    expect(order).toHaveProperty('tax_amount', expect.any(Number));
-    expect(order).toHaveProperty('total', expect.any(Number));
-    expect(order).toHaveProperty('refunded_amount', expect.any(Number));
-    expect(order).toHaveProperty('currency');
-    expect(order).toHaveProperty('note');
-    expect(order).toHaveProperty('lines', expect.any(Array));
-    expect(order).toHaveProperty('other_fees');
-});
-
-test('getPaymentMethods', async () => {
-    const paymentMethods = await consumer.ecommerce.getPaymentMethods();
-    expect(paymentMethods).toBeInstanceOf(Array);
-    expect(paymentMethods.length).toBeGreaterThan(0);
-    expect(paymentMethods[0]).toHaveProperty('id', expect.any(String));
-    expect(paymentMethods[0]).toHaveProperty('name', expect.any(String));
-});
-
-test('getProductCategories', async () => {
-    const productCategories = await consumer.ecommerce.getProductCategories();
-    expect(productCategories).toBeInstanceOf(Array);
-    expect(productCategories.length).toBeGreaterThan(0);
-    expect(productCategories[0]).toHaveProperty('id', expect.any(String));
-    expect(productCategories[0]).toHaveProperty('name', expect.any(String));
-});
-
-test('getCountries', async () => {
-    const countries = await consumer.ecommerce.getCountries();
-    expect(countries).toBeInstanceOf(Array);
-    expect(countries.length).toBeGreaterThan(0);
-    expect(countries[0]).toHaveProperty('code', expect.any(String));
-    expect(countries[0]).toHaveProperty('name', expect.any(String));
-});
-
-test('getTaxes', async () => {
-    const taxes = await consumer.ecommerce.getTaxes();
-    expect(taxes).toBeInstanceOf(Array);
-    expect(taxes.length).toBeGreaterThan(0);
-    expect(taxes[0]).toHaveProperty('id', expect.any(String));
-    expect(taxes[0]).toHaveProperty('rate', expect.any(Number));
-});

package/test/modules/integrations.test.ts

@@ -1,22 +0,0 @@
-import { expect, test } from '@jest/globals';
-import * as chift from '../../src/index';
-import * as dotenv from 'dotenv';
-dotenv.config();
-
-const client = new chift.API({
-    baseUrl: process.env.CHIFT_BACKBONE_API,
-    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
-    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
-    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
-});
-
-test('getIntegrations', async () => {
-    const integrations = await client.Integrations.getIntegrations();
-    expect(integrations).toBeInstanceOf(Array);
-    expect(integrations.length).toBeGreaterThan(0);
-    expect(integrations[0]).toHaveProperty('integrationid', expect.any(Number));
-    expect(integrations[0]).toHaveProperty('name', expect.any(String));
-    expect(integrations[0]).toHaveProperty('status', expect.stringMatching(/^(active|inactive)$/));
-    expect(integrations[0]).toHaveProperty('api', expect.any(String));
-    expect(integrations[0]).toHaveProperty('credentials', expect.any(Array));
-});

package/test/modules/invoicing.test.ts

@@ -1,98 +0,0 @@
-import { beforeAll, expect, test } from '@jest/globals';
-import * as chift from '../../src/index';
-import * as dotenv from 'dotenv';
-import { components } from '../../src/types/public-api/schema';
-dotenv.config();
-
-const client = new chift.API({
-    baseUrl: process.env.CHIFT_BACKBONE_API,
-    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
-    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
-    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
-});
-
-const consumerId = process.env.CHIFT_INVOICING_CONSUMER_ID as string;
-
-let consumer: any;
-beforeAll(async () => {
-    consumer = await client.Consumers.getConsumerById(consumerId);
-});
-
-let invoices: components['schemas']['InvoiceItemOut'][];
-test('getInvoices', async () => {
-    invoices = await consumer.invoicing.getInvoices({
-        invoice_type: 'customer_invoice',
-    });
-    expect(invoices).toBeInstanceOf(Array);
-    expect(invoices.length).toBeGreaterThan(0);
-    expect(invoices[0]).toHaveProperty('id', expect.any(String));
-});
-
-test('getInvoiceById', async () => {
-    if (!invoices.length) {
-        throw new Error('No invoices found to test getInvoiceById');
-    }
-
-    const invoice = await consumer.invoicing.getInvoiceById(invoices[0].id, { include_pdf: false });
-    expect(invoice).toHaveProperty('id', expect.any(String));
-});
-
-let products: components['schemas']['ProductItemOut'][];
-test('getProducts', async () => {
-    products = await consumer.invoicing.getProducts();
-    expect(products).toBeInstanceOf(Array);
-    expect(products.length).toBeGreaterThan(0);
-    expect(products[0]).toHaveProperty('id', expect.any(String));
-});
-
-test('getProductById', async () => {
-    const product = await consumer.invoicing.getProductById(products[0].id);
-    expect(product).toHaveProperty('id', expect.any(String));
-});
-
-let vatCodes: components['schemas']['backbone_common__models__invoicing__VatCode'][];
-test('getTaxes', async () => {
-    vatCodes = await consumer.invoicing.getTaxes();
-    expect(vatCodes).toBeInstanceOf(Array);
-    expect(vatCodes.length).toBeGreaterThan(0);
-    expect(vatCodes[0]).toHaveProperty('id', expect.any(String));
-});
-
-test('getTaxById', async () => {
-    const tax = await consumer.invoicing.getTaxById(vatCodes[0].id);
-    expect(tax).toHaveProperty('id', expect.any(String));
-});
-
-let opportunities: components['schemas']['OpportunityItem'][];
-test.skip('getOpportunities', async () => {
-    opportunities = await consumer.invoicing.getOpportunities();
-    expect(opportunities).toBeInstanceOf(Array);
-    expect(opportunities.length).toBeGreaterThan(0);
-    expect(opportunities[0]).toHaveProperty('id', expect.any(String));
-});
-
-test.skip('getOpportunitiesById', async () => {
-    if (!opportunities.length) {
-        throw new Error('No opportunities found to test getOpportunitiesById');
-    }
-
-    const opportunity = await consumer.invoicing.getOpportunitiesById(opportunities[0].id);
-    expect(opportunity).toHaveProperty('id', expect.any(String));
-});
-
-let contacts: components['schemas']['ContactItemOut'][];
-test('getContacts', async () => {
-    contacts = await consumer.invoicing.getContacts();
-    expect(contacts).toBeInstanceOf(Array);
-    expect(contacts.length).toBeGreaterThan(0);
-    expect(contacts[0]).toHaveProperty('id', expect.any(String));
-});
-
-test('getContactById', async () => {
-    if (!contacts.length) {
-        throw new Error('No contacts found to test getContactById');
-    }
-
-    const contact = await consumer.invoicing.getContactById(contacts[0].id);
-    expect(contact).toHaveProperty('id', expect.any(String));
-});

package/test/modules/payment.test.ts

@@ -1,65 +0,0 @@
-import { beforeAll, expect, test } from '@jest/globals';
-import * as chift from '../../src/index';
-import * as dotenv from 'dotenv';
-import { components } from '../../src/types/public-api/schema';
-dotenv.config();
-
-const client = new chift.API({
-    baseUrl: process.env.CHIFT_BACKBONE_API,
-    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
-    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
-    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
-});
-// TODO: Setup Payment test data
-const consumerId = process.env.CHIFT_PAYMENT_CONSUMER_ID as string;
-
-let consumer: any;
-beforeAll(async () => {
-    consumer = await client.Consumers.getConsumerById(consumerId);
-});
-
-let payments: components['schemas']['PaymentItemOut'][];
-test('getPayments', async () => {
-    payments = await consumer.payment.getPayments();
-    expect(payments).toBeInstanceOf(Array);
-    expect(payments.length).toBeGreaterThan(0);
-    expect(payments[0]).toHaveProperty('id', expect.any(String));
-});
-
-test('getBalances', async () => {
-    const balances: components['schemas']['BalanceItemOut'][] =
-        await consumer.payment.getBalances();
-    expect(balances).toBeInstanceOf(Array);
-    expect(balances.length).toBeGreaterThan(0);
-    expect(balances[0]).toHaveProperty('id', expect.any(String));
-});
-
-test.skip('getTransactions', async () => {
-    const transactions: components['schemas']['TransactionItemOut'][] =
-        await consumer.payment.getTransactions();
-    expect(transactions).toBeInstanceOf(Array);
-    expect(transactions.length).toBeGreaterThan(0);
-    expect(transactions[0]).toHaveProperty('id', expect.any(String));
-});
-
-test.skip('getPayment', async () => {
-    if (!payments.length) {
-        throw new Error('No payments found to test getPayment');
-    }
-
-    const payment: components['schemas']['PaymentItemOut'] = await consumer.payment.getPayment({
-        payment_id: payments[0].id,
-    });
-    expect(payment).toHaveProperty('id', payments[0].id);
-});
-
-test.skip('getRefunds', async () => {
-    const refunds: components['schemas']['RefundItemOut'][] = await consumer.payment.getRefunds({
-        date_from: '2023-01-01',
-        date_to: '2023-01-31',
-        payment_id: payments[0].id,
-    });
-    expect(refunds).toBeInstanceOf(Array);
-    expect(refunds.length).toBeGreaterThan(0);
-    expect(refunds[0]).toHaveProperty('id', expect.any(String));
-});

package/test/modules/pms.test.ts

@@ -1,69 +0,0 @@
-import { beforeAll, expect, test } from '@jest/globals';
-import * as chift from '../../src/index';
-import * as dotenv from 'dotenv';
-import { components } from '../../src/types/public-api/schema';
-dotenv.config();
-
-const client = new chift.API({
-    baseUrl: process.env.CHIFT_BACKBONE_API,
-    clientId: process.env.CHIFT_TESTING_CLIENTID as string,
-    clientSecret: process.env.CHIFT_TESTING_CLIENTSECRET as string,
-    accountId: process.env.CHIFT_TESTING_ACCOUNTID as string,
-});
-// TODO: Setup PMS test data
-const consumerId = process.env.CHIFT_PMS_CONSUMER_ID as string;
-
-let consumer: any;
-beforeAll(async () => {
-    consumer = await client.Consumers.getConsumerById(consumerId);
-});
-
-test.skip('getLocations', async () => {
-    const locations: components['schemas']['PMSLocationItem'][] = await consumer.pms.getLocations();
-    expect(locations).toBeInstanceOf(Array);
-    expect(locations.length).toBeGreaterThan(0);
-    expect(locations[0]).toHaveProperty('id', expect.any(String));
-});
-
-test.skip('getOrders', async () => {
-    const orders: components['schemas']['PMSOrderItem'][] = await consumer.pms.getOrders({
-        date_from: '2023-01-01',
-        date_to: '2023-01-31',
-    });
-    expect(orders).toBeInstanceOf(Array);
-    expect(orders.length).toBeGreaterThan(0);
-    expect(orders[0]).toHaveProperty('id', expect.any(String));
-});
-
-test.skip('getPaymentMethods', async () => {
-    const paymentMethods: components['schemas']['PMSPaymentMethods'][] =
-        await consumer.pms.getPaymentMethods();
-    expect(paymentMethods).toBeInstanceOf(Array);
-    expect(paymentMethods.length).toBeGreaterThan(0);
-    expect(paymentMethods[0]).toHaveProperty('id', expect.any(String));
-});
-
-test.skip('getClosure', async () => {
-    const closure: components['schemas']['PMSClosureItem'] = await consumer.pms.getClosure(
-        '2023-01-01'
-    );
-    expect(closure).toHaveProperty('id', expect.any(String));
-});
-
-test.skip('getPayments', async () => {
-    const payments: components['schemas']['PMSPaymentItem'][] = await consumer.pms.getPayments({
-        date_from: '2023-01-01',
-        date_to: '2023-01-31',
-    });
-    expect(payments).toBeInstanceOf(Array);
-    expect(payments.length).toBeGreaterThan(0);
-    expect(payments[0]).toHaveProperty('id', expect.any(String));
-});
-
-test.skip('getAccountingCategories', async () => {
-    const accountingCategories: components['schemas']['PMSAccountingCategoryItem'][] =
-        await consumer.pms.getAccountingCategories();
-    expect(accountingCategories).toBeInstanceOf(Array);
-    expect(accountingCategories.length).toBeGreaterThan(0);
-    expect(accountingCategories[0]).toHaveProperty('id', expect.any(String));
-});