@chift/chift-nodejs 0.0.1

package/test/modules/ecommerce.test.ts

@@ -0,0 +1,177 @@
+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));
+});
+
+/*
+test('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');
+});

package/test/modules/integrations.test.ts

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,145 @@
+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;
+
+let cashpadConsumer: any;
+let lightspeedConsumer: any;
+beforeAll(async () => {
+    cashpadConsumer = await client.Consumers.getConsumerById(cashpadConsumerId);
+    lightspeedConsumer = await client.Consumers.getConsumerById(lightspeedConsumerId);
+});
+
+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']['OrderItem'][];
+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));
+});

package/test/modules/sync.test.ts

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,23 @@
+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);
+});

package/test/modules/webhooks.test.ts

@@ -0,0 +1,92 @@
+import { afterAll, beforeAll, expect, test } from '@jest/globals';
+import * as chift from '../../src/index';
+import * as dotenv from 'dotenv';
+import axios from 'axios';
+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,
+});
+
+let webhook: any;
+
+beforeAll(async () => {
+    webhook = await client.Webhooks.registerWebhook({
+        event: 'account.connection.created',
+        url: 'https://test',
+        signingsecret: 'secret',
+    });
+    expect(webhook).toHaveProperty('status', 'active');
+    expect(webhook).toHaveProperty('webhookid', expect.any(String));
+    expect(webhook).toHaveProperty('accountid', expect.any(String));
+    expect(webhook).toHaveProperty('createdby');
+    expect(webhook).toHaveProperty('createdon');
+    expect(webhook).toHaveProperty('event', 'account.connection.created');
+    expect(webhook).toHaveProperty('url', 'https://test');
+    expect(webhook).toHaveProperty('status', 'active');
+    expect(webhook).toHaveProperty('integrationid');
+});
+
+test('getWebhookTypes', async () => {
+    const webhookTypes = await client.Webhooks.getWebhookTypes();
+    expect(webhookTypes).toBeInstanceOf(Array);
+    expect(webhookTypes.length).toBeGreaterThan(0);
+    expect(webhookTypes[0]).toHaveProperty('event', expect.any(String));
+    expect(webhookTypes[0]).toHaveProperty('api');
+});
+
+test('getWebhooks', async () => {
+    const webhooks = await client.Webhooks.getWebhooks();
+    expect(webhooks).toBeInstanceOf(Array);
+    expect(webhooks.length).toBeGreaterThan(0);
+    expect(webhooks[0]).toHaveProperty('webhookid', expect.any(String));
+});
+
+test('getWebhookById', async () => {
+    const webhookWithId = await client.Webhooks.getWebhookById(webhook.webhookid);
+    expect(webhookWithId).toHaveProperty('webhookid', webhook.webhookid);
+    expect(webhookWithId).toHaveProperty('accountid', expect.any(String));
+    expect(webhookWithId).toHaveProperty('createdby');
+    expect(webhookWithId).toHaveProperty('createdon');
+    expect(webhookWithId).toHaveProperty('event', expect.any(String));
+    expect(webhookWithId).toHaveProperty('url', expect.any(String));
+    expect(webhookWithId).toHaveProperty('status', expect.any(String));
+    expect(webhookWithId).toHaveProperty('integrationid');
+});
+
+test('updateWebhookById', async () => {
+    const updatedWebhook = await client.Webhooks.updateWebhookById(webhook.webhookid, {
+        status: 'inactive',
+    });
+    expect(updatedWebhook).toHaveProperty('webhookid', expect.any(String));
+    expect(updatedWebhook).toHaveProperty('accountid', expect.any(String));
+    expect(updatedWebhook).toHaveProperty('createdby');
+    expect(updatedWebhook).toHaveProperty('createdon');
+    expect(updatedWebhook).toHaveProperty('event', 'account.connection.created');
+    expect(updatedWebhook).toHaveProperty('url', 'https://test');
+    expect(updatedWebhook).toHaveProperty('status', 'inactive');
+    expect(updatedWebhook).toHaveProperty('integrationid');
+});
+
+test('getWebhookLogsByWebhookId', async () => {
+    const webhookLogs = await client.Webhooks.getWebhookLogsByWebhookId(webhook.webhookid);
+    expect(webhookLogs).toBeInstanceOf(Array);
+});
+
+afterAll(async () => {
+    expect.assertions(1);
+    try {
+        await client.Webhooks.unRegisterWebhook(webhook.webhookid);
+        await client.Webhooks.getWebhookById(webhook.webhookid);
+    } catch (e: unknown) {
+        if (axios.isAxiosError(e)) {
+            expect(e.message).toMatch('Request failed with status code 404');
+            return;
+        }
+
+        throw e;
+    }
+});

package/test/set_envs.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+export CHIFT_ACCOUNT_ID="c16e37b6-b816-4265-8924-f2aeefcbe7fe"
+export CHIFT_AXONAUT_CONSUMER_ID="05a68dfd-4fcd-45d5-93c5-c987587ebad5"
+export CHIFT_BASE_URL="https://api.chift.site"
+export CHIFT_CASHPAD_CONSUMER_ID="a6572100-fbb6-4d9d-a507-773dbe6b1042"
+export CHIFT_CLIENT_ID="IzagGvQFLKnFRsW"
+export CHIFT_CLIENT_SECRET="NvroyDxDjjA6ylxmotjz"
+export CHIFT_LIGHTSPEED_CONSUMER_ID="d0b5d8c6-b7b0-4714-af0d-eec857e91feb"
+export CHIFT_ODOO_CONSUMER_ID="84a6cb97-a641-43ab-ac63-d9bd7ecb85e0"
+export CHIFT_TEST_SYNC_ID="1174849b-f710-454b-b088-df0ea38089f7"
+export CHIFT_WOOCOMMERCE_CONSUMER_ID="dd168ff5-3a40-4b65-bd83-4dde1efb316b"
+export CHIFT_SYNC_CONSUMER_ID="05a68dfd-4fcd-45d5-93c5-c987587ebad5"
+export CHIFT_TEST_DATASTORE_NAME="CONTACTS"
+export CHIFT_TEST_DATASTORE_ID="06794cc1-011e-4a49-8f83-cf98e04ce64d"