@chift/chift-nodejs 1.0.16 → 1.0.18

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_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID 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,208 +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_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
-});
-
-const consumerId = process.env.CHIFT_WOOCOMMERCE_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']['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');
-});
-
-test('getProductVariantById', async () => {
-    if (!products?.length) {
-        throw new Error('No product to test');
-    }
-
-    if (!products[0].variants) {
-        throw new Error('No product variant to test');
-    }
-
-    const variant = await consumer.ecommerce.getProductVariantById(products[0].variants[0].id);
-    expect(variant).toBeTruthy();
-    expect(variant).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('updateAvailableQuantity', async () => {
-    if (!products?.length) {
-        throw new Error('No product to test');
-    }
-
-    if (!products[0].variants) {
-        throw new Error('No product variant to test');
-    }
-
-    const product = await consumer.ecommerce.updateAvailableQuantity(products[0].variants[0].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: '2021-10-01',
-        date_to: '2021-12-31',
-    });
-    expect(orders).toBeInstanceOf(Array);
-});
-
-test('getOrder', async () => {
-    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_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID 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,88 +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_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
-});
-
-const consumerId = process.env.CHIFT_AXONAUT_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',
-        date_from: '2023-01-01',
-        date_to: '2023-01-31',
-    });
-    expect(invoices).toBeInstanceOf(Array);
-    expect(invoices.length).toBeGreaterThan(0);
-    expect(invoices[0]).toHaveProperty('id', expect.any(String));
-});
-
-test('getInvoiceById', async () => {
-    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']['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('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('getOpportunitiesById', async () => {
-    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 () => {
-    const contact = await consumer.invoicing.getContactById(contacts[0].id);
-    expect(contact).toHaveProperty('id', expect.any(String));
-});

package/test/modules/pos.test.ts

@@ -1,166 +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_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
-});
-
-// Split testing between two APIs to support all endpoints
-const cashpadConsumerId = process.env.CHIFT_CASHPAD_CONSUMER_ID as string;
-const lightspeedConsumerId = process.env.CHIFT_LIGHTSPEED_CONSUMER_ID as string;
-const popinaConsumerId = process.env.CHIFT_POPINA_CONSUMER_ID as string;
-
-let cashpadConsumer: any;
-let lightspeedConsumer: any;
-let popinaConsumer: any;
-beforeAll(async () => {
-    cashpadConsumer = await client.Consumers.getConsumerById(cashpadConsumerId);
-    lightspeedConsumer = await client.Consumers.getConsumerById(lightspeedConsumerId);
-    popinaConsumer = await client.Consumers.getConsumerById(popinaConsumerId);
-});
-
-test('getLocations', async () => {
-    const locations = await lightspeedConsumer.pos.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));
-});
-
-let orders: components['schemas']['POSOrderItem'][];
-test('getOrders', async () => {
-    orders = await lightspeedConsumer.pos.getOrders({
-        date_from: '2023-01-11',
-        date_to: '2023-02-28',
-    });
-    expect(orders).toBeInstanceOf(Array);
-    expect(orders.length).toBeGreaterThan(0);
-    expect(orders[0]).toHaveProperty('id', expect.any(String));
-});
-
-// TODO: Fix Method Not Allowed error
-test.skip('createCustomer', async () => {
-    const body = {
-        first_name: 'John',
-        last_name: 'Doe',
-        email: 'test@test.com',
-    };
-    const customer = await cashpadConsumer.pos.createCustomer(body);
-    expect(customer).toBeTruthy();
-    expect(customer).toHaveProperty('id', expect.any(String));
-    expect(customer).toHaveProperty('name');
-});
-
-// TODO: Fix timeout error
-let customers: any[] = [];
-test.skip('getCustomers', async () => {
-    customers = await cashpadConsumer.pos.getCustomers();
-    expect(customers).toBeInstanceOf(Array);
-    expect(customers.length).toBeGreaterThan(0);
-    expect(customers[0]).toHaveProperty('id', expect.any(String));
-});
-
-// TODO: Fix The day parameter is missing error
-test.skip('getOrder', async () => {
-    const order = await lightspeedConsumer.pos.getOrder(orders[0].id);
-    expect(order).toBeTruthy();
-    expect(order).toHaveProperty('id', expect.any(String));
-    expect(order).toHaveProperty('order_number');
-    expect(order).toHaveProperty('creation_date', expect.any(String));
-    expect(order).toHaveProperty('closing_date');
-    expect(order).toHaveProperty('service_date');
-    expect(order).toHaveProperty('total', expect.any(Number));
-    expect(order).toHaveProperty('tax_amount', expect.any(Number));
-    expect(order).toHaveProperty('total_discount');
-    expect(order).toHaveProperty('total_refund');
-    expect(order).toHaveProperty('total_tip', expect.any(Number));
-    expect(order).toHaveProperty('items', expect.any(Array));
-    expect(order).toHaveProperty('payments', expect.any(Array));
-    expect(order).toHaveProperty('currency');
-    expect(order).toHaveProperty('country');
-    expect(order).toHaveProperty('loyalty');
-    expect(order).toHaveProperty('customer_id');
-    expect(order).toHaveProperty('location_id');
-    expect(order).toHaveProperty('taxes');
-});
-
-// TODO: Fix getCustomers first
-test.skip('getCustomer', async () => {
-    const customer = await cashpadConsumer.pos.getCustomer(customers[0].id);
-    expect(customer).toBeTruthy();
-    expect(customer).toHaveProperty('id', expect.any(String));
-    expect(customer).toHaveProperty('name');
-});
-
-test('getPaymentMethods', async () => {
-    const paymentMethods = await lightspeedConsumer.pos.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));
-    expect(paymentMethods[0]).toHaveProperty('extra');
-});
-
-test('getSales', async () => {
-    const sales = await lightspeedConsumer.pos.getSales({
-        date_from: '2022-08-11',
-        date_to: '2022-08-12',
-    });
-    expect(sales).toHaveProperty('total', expect.any(Number));
-    expect(sales).toHaveProperty('tax_amount', expect.any(Number));
-    expect(sales).toHaveProperty('taxes', expect.any(Array));
-});
-
-test('getClosure', async () => {
-    const closure = await lightspeedConsumer.pos.getClosure('2022-08-11');
-    expect(closure).toHaveProperty('date', expect.any(String));
-    expect(closure).toHaveProperty('status');
-});
-
-test('getPayments', async () => {
-    const payments = await lightspeedConsumer.pos.getPayments({
-        date_from: '2023-01-11',
-        date_to: '2023-02-28',
-    });
-    expect(payments).toBeInstanceOf(Array);
-    expect(payments.length).toBeGreaterThan(0);
-    expect(payments[0]).toHaveProperty('id');
-    expect(payments[0]).toHaveProperty('payment_method_id');
-    expect(payments[0]).toHaveProperty('payment_method_name');
-    expect(payments[0]).toHaveProperty('total', expect.any(Number));
-    expect(payments[0]).toHaveProperty('tip', expect.any(Number));
-    expect(payments[0]).toHaveProperty('status');
-    expect(payments[0]).toHaveProperty('currency');
-    expect(payments[0]).toHaveProperty('date');
-});
-
-// TODO: Fix API Resource does not exist
-test.skip('updateOrder', async () => {
-    const order = await lightspeedConsumer.pos.updateOrder(orders[0].id, {});
-    expect(order).toBeTruthy();
-    expect(order).toHaveProperty('id', expect.any(String));
-});
-
-test('getProducts', async () => {
-    const products = await popinaConsumer.pos.getProducts();
-    expect(products).toBeInstanceOf(Array);
-    expect(products.length).toBeGreaterThan(0);
-});
-
-test('getProductCategories', async () => {
-    const productCategories = await popinaConsumer.pos.getProductCategories();
-    expect(productCategories).toBeInstanceOf(Array);
-    expect(productCategories.length).toBeGreaterThan(0);
-});
-
-test('getAccountingCategories', async () => {
-    const accountingCategories = await popinaConsumer.pos.getAccountingCategories();
-    expect(accountingCategories).toBeInstanceOf(Array);
-    expect(accountingCategories.length).toBeGreaterThan(0);
-});

package/test/modules/sync.test.ts

@@ -1,60 +0,0 @@
-import { beforeAll, 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_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
-});
-
-const flowName = 'Je suis un flux de test';
-
-let sync: any;
-let flow: any;
-
-beforeAll(async () => {
-    const syncId = process.env.CHIFT_TEST_SYNC_ID as string;
-    sync = await client.Syncs.getSyncById(syncId);
-});
-
-test('createFlow', async () => {
-    flow = await sync.createFlow(
-        {
-            name: flowName,
-            description: 'Flux de test',
-            execution: {
-                type: 'code',
-            },
-            trigger: {
-                type: 'event',
-            },
-            config: {},
-        },
-        async (consumer: any, flowContext: any) => {
-            console.log(`Mon flow_id : ${flowContext.flow_id}`);
-            console.log(`Bonjour, ceci est un test, on exécute le flux pour consumer: ${consumer}`);
-        }
-    );
-
-    expect(flow).toHaveProperty('flowId');
-    expect(flow).toHaveProperty('name', flowName);
-});
-
-test('getFlows', async () => {
-    const flows = await sync.getFlows();
-    expect(flows).toBeInstanceOf(Array);
-});
-
-test('getFlowByName', async () => {
-    const flowWithName = await sync.getFlowByName(flow.name);
-    expect(flowWithName).toHaveProperty('name', flow.name);
-});
-
-test('getFlowById', async () => {
-    const flowWithId = await sync.getFlowById(flow.flowId);
-    expect(flowWithId).toHaveProperty('flowId', flow.flowId);
-});

package/test/modules/syncs.test.ts

@@ -1,23 +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_BASE_URL,
-    clientId: process.env.CHIFT_CLIENT_ID as string,
-    clientSecret: process.env.CHIFT_CLIENT_SECRET as string,
-    accountId: process.env.CHIFT_ACCOUNT_ID as string,
-});
-
-test('getSyncs', async () => {
-    const syncs = await client.Syncs.getSyncs();
-    expect(syncs).toBeInstanceOf(Array);
-});
-
-test('getSyncById', async () => {
-    const syncId = process.env.CHIFT_TEST_SYNC_ID as string;
-    const sync = await client.Syncs.getSyncById(syncId);
-    expect(sync).toHaveProperty('syncid', syncId);
-});