From 9e041416bdc09a3f34d6f2da72bde6788770e39b Mon Sep 17 00:00:00 2001
From: Paul Rill <55083975+PaulRill00@users.noreply.github.com>
Date: Tue, 13 Feb 2024 16:39:48 +0100
Subject: [PATCH] =?UTF-8?q?feat:=20=E2=9C=A8=20added=20CsvOrder=20model=20?=
 =?UTF-8?q?+=20endpoints=20(#7)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat: :sparkles: added CsvOrder model + endpoints

* docs: :memo: updated docs about CsvOrder

* fix: PR feedback

* chore: type error

---------

Co-authored-by: Koen van Staveren <koenvanstaveren@hotmail.com>
---
 docs/CsvOrder.md                    |  98 ++++++++++++++++++
 docs/PrintOne.md                    |  36 +++++++
 src/PrintOne.ts                     |  72 ++++++++++---
 src/enums/CsvStatus.ts              |  29 ++++++
 src/index.ts                        |   2 +
 src/models/CsvOrder.ts              | 142 ++++++++++++++++++++++++++
 src/models/_interfaces/ICsvOrder.ts |  24 +++++
 test/CsvOrder.spec.ts               | 112 +++++++++++++++++++++
 test/PrintOne.spec.ts               | 151 +++++++++++++++++++++++++++-
 test/assets/test.csv                |   3 +
 10 files changed, 652 insertions(+), 17 deletions(-)
 create mode 100644 docs/CsvOrder.md
 create mode 100644 src/enums/CsvStatus.ts
 create mode 100644 src/models/CsvOrder.ts
 create mode 100644 src/models/_interfaces/ICsvOrder.ts
 create mode 100644 test/CsvOrder.spec.ts
 create mode 100644 test/assets/test.csv

diff --git a/docs/CsvOrder.md b/docs/CsvOrder.md
new file mode 100644
index 0000000..abe07eb
--- /dev/null
+++ b/docs/CsvOrder.md
@@ -0,0 +1,98 @@
+Contains all information about a given CsvOrder
+
+# Fields
+
+| Name                  | Type                                 | Description                                                                                                                                                             |
+| --------------------- | ------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `id`                  | `string`                             | The ID of the order.                                                                                                                                                    |
+| `templateId`          | `string`                             | The ID of the template the order is based on.                                                                                                                           |
+| `finish`              | `string`                             | The finish of the order. Can be `GLOSSY` or `MATT`.                                                                                                                     |
+| `format`              | `string`                             | The format of the order. Can be `POSTCARD_A5`, `POSTCARD_A6`, `POSTCARD_SQ14` or `GREETINGCARD_SQ15`.                                                                   |
+| `mergeVariableMapping`      | `object`                       | The merge variables of the order. Keys are the merge variable names.                                                                                                    |
+| `sender`              | [`Address`](#Address) \| `undefined` | The sender of the order.                                                                                                                                                |
+| `recipientMapping`    | [`Address`](#Address)                | The mapping of the recipient.                                                                                                                                             |
+| `definitiveCountryId` | `string`                             | The ID of the definitive country of the order.                                                                                                                          |
+| `billingId`           | `string` \| `undefined`              | The ID assigned to the csv order by the customer.                                                                                                                           |
+| `isBillable`          | `boolean`                            | Whether the csv order is billable. True when an live API key is used, false when a test API key is used.                                                                    |
+| `status`              | `string`                             | The status of the csv order. Can be `order_created` or `order_processed` |
+| `friendlyStatus`      | `string`                             | The friendly status of the csv order. Can be `Processing` or `Success`                                                      |
+| `estimatedOrderCount` | `number`                             | The amount of initial orders in the CSV
+| `failedOrderCount`    | `number`                             | The amount of orders which have failed to be processed
+| `processedOrderCount` | `number`                             | The amount of orders which have successfully been processed
+| `totalOrderCount`     | `number`                             | The total amount of orders failed or processed
+| `sendDate`            | `Date`                               | The date the order will be sent on.                                                                                                                                     |
+| `createdAt`           | `Date`                               | The date and time the order was created.                                                                                                                                |
+| `updatedAt`           | `Date`                               | The date and time the order was last updated.                                                                                                                           |
+
+# Methods
+
+## `.getTemplate()`
+
+Get the template the order is based on. Uses [`PrintOne.getTemplate()`](./PrintOne#gettemplateid).
+
+**Returns: [`Promise<Template>`](./Template)**
+
+**Example**
+
+```js
+const order = await client.getOrder("example-order-id");
+const template = await order.getTemplate();
+```
+
+---
+
+## `.refresh()`
+
+Refresh the CsvOrder data to get the latest information
+
+**Returns: `Promise<void>`**
+
+**Example**
+
+```js
+const csvOrder: CsvOrder;
+await csvOrder.refresh();
+```
+
+---
+
+## [`CsvOrder.getOrders([options])`](./PrintOne#getordersoptions)
+
+Get all orders generated by the CSV.
+
+**Parameters**
+
+| Name                            | Type                          | Default          | Description                                                                                                                        |
+| ------------------------------- | ----------------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| `options.limit`                 | `number`                      | `10`             | The maximum number of orders to return.                                                                                            |
+| `options.page`                  | `number`                      | `1`              | The page of orders to return.                                                                                                      |
+| `options.sortBy`                | [`sort`](./Filtering#Sorting) | `createdAt:DESC` | The field(s) to sort the orders by. Can be `createdAt`, `anonymizedAt`, `updatedAt`, `friendlyStatus` or `sendDate`                |
+| `options.filter.friendlyStatus` | `string` \| `string[]`        | `undefined`      | The friendly status(es) of the order(s) to filter by. Can be `Processing`, `Success`, `Sent`, `Scheduled`, `Cancelled` or `Failed` |
+| `options.filter.billingId`      | `string` \| `string[]`        | `undefined`      | The billing ID(s) of the order(s) to filter by.                                                                                    |
+| `options.filter.format`         | `string` \| `string[]`        | `undefined`      | The format(s) of the order(s) to filter by. Can be `POSTCARD_A5`, `POSTCARD_A6`, `POSTCARD_SQ14` or `GREETINGCARD_SQ15`            |
+| `options.filter.finish`         | `string` \| `string[]`        | `undefined`      | The finish(es) of the order(s) to filter by. Can be `GLOSSY` or `MATTE`                                                            |
+| `options.filter.isBillable`     | `boolean`                     | `undefined`      | Whether the order(s) are live order or test orders.                                                                                |
+| `options.filter.createdAt`      | [`date`](./Filtering#Date)    | `undefined`      | The date(s) the order(s) were created on.                                                                                          |
+
+**Returns: [`Promise<PaginatedResponse<Order>>`](./Order)**
+
+**Example**
+
+```js
+const orders = await csvOrder.getOrders({
+  limit: 20,
+  page: 1,
+  sortBy: "createdAt:ASC",
+  filter: {
+    friendlyStatus: "Success",
+    billingId: "example-billing-id",
+    format: Format.POSTCARD_A5,
+    finish: Finish.GLOSSY,
+    isBillable: true,
+    createdAt: {
+      from: "2020-01-01",
+      to: "2020-01-31",
+    },
+  },
+});
+```
diff --git a/docs/PrintOne.md b/docs/PrintOne.md
index 293ecb7..227a952 100644
--- a/docs/PrintOne.md
+++ b/docs/PrintOne.md
@@ -243,3 +243,39 @@ const orders = await client.getOrders({
   },
 });
 ```
+
+---
+
+## `.createCsvOrder(data)`
+
+Create a new csv order.
+
+**Parameters**
+
+| Name   | Type     | Description                                                                              |
+| ------ | -------- | ---------------------------------------------------------------------------------------- |
+| `data` | `object` | The data to create the order with. See [`CsvOrder`](./CsvOrder#createcsvorderdata) for more info. |
+
+**Returns: [`Promise<CsvOrder>`](./CsvOrder)**
+
+**Example**
+
+```js
+const order = await client.createCsvOrder({
+   mapping: {
+      recipient: {
+        city: "{{City}}",
+        name: "{{FirstName}} {{LastName}}",
+        address: "{{Street}} {{HouseNr}}",
+        country: "{{Country}}",
+        postalCode: "{{ZIP}}",
+      },
+      mergeVariables: {
+        name: "{{FirstName}}",
+        coupon: "{{Coupon}}",
+      },
+    },
+    template: template,
+    file: file,
+});
+```
diff --git a/src/PrintOne.ts b/src/PrintOne.ts
index c6fb7d8..3bd0339 100644
--- a/src/PrintOne.ts
+++ b/src/PrintOne.ts
@@ -24,13 +24,14 @@ import { IOrder } from "./models/_interfaces/IOrder";
 import { FriendlyStatus } from "./enums/Status";
 import { Format } from "./enums/Format";
 import { AxiosHTTPHandler } from "./AxiosHttpHandler";
+import { CreateCsvOrder, CsvOrder } from "./models/CsvOrder";
+import { ICsvOrder } from "./models/_interfaces/ICsvOrder";
 
 export type RequestHandler = new (
   token: string,
   options: Required<PrintOneOptions>,
   debug: debug.Debugger,
-) => HttpHandler<unknown, unknown>;
-
+) => HttpHandler<{ headers: Record<string, string> }, unknown>;
 export type PrintOneOptions = Partial<{
   url: string;
   version: "v2";
@@ -52,6 +53,21 @@ export type Protected = {
   printOne: PrintOne;
 };
 
+export type OrderPaginatedQuery = PaginationOptions<
+  "createdAt" | "anonymizedAt" | "updatedAt" | "friendlyStatus" | "sendDate"
+> & {
+  filter?: {
+    friendlyStatus?: InFilter<FriendlyStatus>;
+    billingId?: InFilter;
+    format?: InFilter<Format>;
+    // finish?: InFilter<Finish>;
+    isBillable?: boolean;
+    createdAt?: DateFilter;
+    anonymizedAt?: DateFilter | boolean;
+    csvId?: InFilter;
+  };
+};
+
 export class PrintOne {
   private readonly _protected: Partial<Protected> = {
     debug: debug("print-one"),
@@ -249,6 +265,43 @@ export class PrintOne {
     return new Order(this.protected, response);
   }
 
+  public async createCsvOrder(data: CreateCsvOrder): Promise<CsvOrder> {
+    const templateId =
+      typeof data.template === "string" ? data.template : data.template.id;
+
+    const formData = new FormData();
+    formData.append(
+      "file",
+      new Blob([data.file], { type: "text/csv" }),
+      "upload.csv",
+    );
+    formData.append("mapping", JSON.stringify(data.mapping));
+    formData.append(
+      "orderData",
+      JSON.stringify({
+        sender: data.sender,
+        templateId,
+        finish: data.finish,
+        billingId: data.billingId,
+      }),
+    );
+
+    const response = await this.client.POST<{ id: string }>(
+      "orders/csv",
+      formData,
+      {
+        headers: {
+          "Content-Type": "multipart/form-data",
+        },
+      },
+    );
+
+    const id = response.id;
+    const csvInfo = await this.client.GET<ICsvOrder>(`orders/csv/${id}`);
+
+    return new CsvOrder(this.protected, csvInfo);
+  }
+
   /**
    * Get an order by its id.
    * @param { string } id The id of the order.
@@ -270,19 +323,7 @@ export class PrintOne {
    * @throws { PrintOneError } If the order could not be found.
    */
   public async getOrders(
-    options: PaginationOptions<
-      "createdAt" | "anonymizedAt" | "updatedAt" | "friendlyStatus" | "sendDate"
-    > & {
-      filter?: {
-        friendlyStatus?: InFilter<FriendlyStatus>;
-        billingId?: InFilter;
-        format?: InFilter<Format>;
-        // finish?: InFilter<Finish>;
-        isBillable?: boolean;
-        createdAt?: DateFilter;
-        anonymizedAt?: DateFilter | boolean;
-      };
-    } = {},
+    options: OrderPaginatedQuery = {},
   ): Promise<PaginatedResponse<Order>> {
     let params = {
       ...sortToQuery(options),
@@ -291,6 +332,7 @@ export class PrintOne {
       ...inFilterToQuery("format", options.filter?.format),
       // ...inFilterToQuery("finish", options.filter?.finish),
       ...dateFilterToQuery("createdAt", options.filter?.createdAt),
+      ...inFilterToQuery("csvOrderId", options.filter?.csvId),
     };
 
     if (typeof options.filter?.isBillable === "boolean") {
diff --git a/src/enums/CsvStatus.ts b/src/enums/CsvStatus.ts
new file mode 100644
index 0000000..b0abe71
--- /dev/null
+++ b/src/enums/CsvStatus.ts
@@ -0,0 +1,29 @@
+export const CsvStatus: {
+  order_created: "order_created";
+  order_processed: "order_processed";
+} = {
+  order_created: "order_created",
+  order_processed: "order_processed",
+};
+
+export type CsvStatus = (typeof CsvStatus)[keyof typeof CsvStatus];
+
+export const FriendlyCsvStatusText: {
+  Processing: "Processing";
+  Success: "Success";
+} = {
+  Processing: "Processing",
+  Success: "Success",
+};
+
+export type FriendlyCsvStatusText =
+  (typeof FriendlyCsvStatusText)[keyof typeof FriendlyCsvStatusText];
+
+export const FriendlyCsvStatus: {
+  [key in CsvStatus]: FriendlyCsvStatusText;
+} = {
+  order_created: "Processing",
+  order_processed: "Success",
+};
+
+export type FriendlyCsvStatus = typeof FriendlyCsvStatus;
diff --git a/src/index.ts b/src/index.ts
index 8b0d4ba..e4b366d 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -7,6 +7,7 @@ export * from "./PrintOne";
 // Models
 export * from "./models/Address";
 export * from "./models/Company";
+export * from "./models/CsvOrder";
 export * from "./models/CustomFile";
 export * from "./models/Order";
 export * from "./models/PaginatedResponse";
@@ -15,6 +16,7 @@ export * from "./models/PreviewDetails";
 export * from "./models/Template";
 
 // Enums
+export * from "./enums/CsvStatus";
 export * from "./enums/Finish";
 export * from "./enums/Format";
 export * from "./enums/Status";
diff --git a/src/models/CsvOrder.ts b/src/models/CsvOrder.ts
new file mode 100644
index 0000000..a0118ca
--- /dev/null
+++ b/src/models/CsvOrder.ts
@@ -0,0 +1,142 @@
+import { OrderPaginatedQuery, Protected } from "../PrintOne";
+import { Finish } from "../enums/Finish";
+import { Format } from "../enums/Format";
+import { Address } from "./Address";
+import { Template } from "./Template";
+import { ICsvOrder } from "./_interfaces/ICsvOrder";
+import { CsvStatus, FriendlyCsvStatusText } from "src/enums/CsvStatus";
+import { Order } from "./Order";
+import { PaginatedResponse } from "./PaginatedResponse";
+
+export type CreateCsvOrder = {
+  file: ArrayBuffer;
+  mapping: {
+    recipient: Address;
+    mergeVariables?: Record<string, string>;
+  };
+  template: Template | string;
+  finish?: Finish;
+  billingId?: string;
+  sender?: Address;
+};
+
+export class CsvOrder {
+  private _data: ICsvOrder;
+
+  constructor(
+    private readonly _protected: Protected,
+    _data: ICsvOrder,
+  ) {
+    this._data = _data;
+  }
+
+  public get id(): string {
+    return this._data.id;
+  }
+
+  public get templateId(): string {
+    return this._data.templateId;
+  }
+
+  public get finish(): Finish {
+    return this._data.finish as Finish;
+  }
+
+  public get format(): Format {
+    return this._data.format as Format;
+  }
+
+  public get recipientMapping(): Address {
+    return this._data.mapping.recipient;
+  }
+
+  public get mergeVariableMapping(): Record<string, string> {
+    return this._data.mapping.mergeVariables;
+  }
+
+  public get sender(): Address | undefined {
+    return this._data.sender;
+  }
+
+  public get billingId(): string | undefined {
+    return this._data.billingId;
+  }
+
+  /**
+   * True if the order is created using a live API key.
+   */
+  public get isBillable(): boolean {
+    return this._data.isBillable;
+  }
+
+  public get status(): CsvStatus {
+    return this._data.status as CsvStatus;
+  }
+
+  public get friendlyStatus(): FriendlyCsvStatusText {
+    return this._data.friendlyStatus as FriendlyCsvStatusText;
+  }
+
+  public get estimatedOrderCount(): number {
+    return this._data.estimatedOrderCount;
+  }
+
+  public get failedOrderCount(): number {
+    return this._data.failedOrderCount;
+  }
+
+  public get processedOrderCount(): number {
+    return this._data.processedOrderCount;
+  }
+
+  public get totalOrderCount(): number {
+    return this._data.totalOrderCount;
+  }
+
+  public get sendDate(): Date {
+    return new Date(this._data.sendDate);
+  }
+
+  public get createdAt(): Date {
+    return new Date(this._data.createdAt);
+  }
+
+  public get updatedAt(): Date {
+    return new Date(this._data.updatedAt);
+  }
+
+  /**
+   * Get the template of the order
+   * @throws { PrintOneError } If the template could not be fetched.
+   */
+  public async getTemplate(): Promise<Template> {
+    return this._protected.printOne.getTemplate(this.templateId);
+  }
+
+  /**
+   * Get all orders from a csv order
+   */
+  public async getOrders(
+    args: Omit<OrderPaginatedQuery, "filter"> & {
+      filter?: Omit<OrderPaginatedQuery["filter"], "csvId">;
+    },
+  ): Promise<PaginatedResponse<Order>> {
+    return this._protected.printOne.getOrders({
+      ...args,
+      filter: {
+        ...args.filter,
+        csvId: this.id,
+      },
+    });
+  }
+
+  /**
+   * Refresh the order, can be used to poll for the status
+   * @throws { PrintOneError } If the order could not be refreshed.
+   */
+  public async refresh(): Promise<void> {
+    this._data = await this._protected.client.GET<ICsvOrder>(
+      `orders/csv/${this.id}`,
+    );
+  }
+}
diff --git a/src/models/_interfaces/ICsvOrder.ts b/src/models/_interfaces/ICsvOrder.ts
new file mode 100644
index 0000000..55dc8c0
--- /dev/null
+++ b/src/models/_interfaces/ICsvOrder.ts
@@ -0,0 +1,24 @@
+import { Address } from "../../models/Address";
+
+export type ICsvOrder = {
+  id: string;
+  estimatedOrderCount: number;
+  failedOrderCount: number;
+  processedOrderCount: number;
+  totalOrderCount: number;
+  templateId: string;
+  mapping: {
+    recipient: Address;
+    mergeVariables: Record<string, string>;
+  };
+  finish: string;
+  format: string;
+  createdAt: Date;
+  updatedAt: Date;
+  sendDate: Date;
+  isBillable: boolean;
+  status: string;
+  friendlyStatus: string;
+  sender?: Address;
+  billingId?: string;
+};
diff --git a/test/CsvOrder.spec.ts b/test/CsvOrder.spec.ts
new file mode 100644
index 0000000..aefc4ad
--- /dev/null
+++ b/test/CsvOrder.spec.ts
@@ -0,0 +1,112 @@
+import {
+  CsvOrder,
+  CsvStatus,
+  Finish,
+  Format,
+  PaginatedResponse,
+  Status,
+  Template,
+} from "../src";
+import { client } from "./client";
+import { sleep } from "../src/utils";
+import * as fs from "fs";
+import * as path from "path";
+
+let file: ArrayBuffer = null as unknown as ArrayBuffer;
+let order: CsvOrder = null as unknown as CsvOrder;
+let template: Template = null as unknown as Template;
+
+beforeAll(async function () {
+  file = fs.readFileSync(path.join(__dirname, "assets/test.csv"));
+
+  template = await client.createTemplate({
+    name: `Test Order ${new Date().toISOString().replaceAll(":", "-")}`,
+    format: Format.POSTCARD_SQ15,
+    labels: ["library-unit-test"],
+    pages: ["{{name}}, your free coupon: {{coupon}}", "page2"],
+  });
+});
+
+beforeEach(async function () {
+  order = await client.createCsvOrder({
+    mapping: {
+      recipient: {
+        city: "{{City}}",
+        name: "{{FirstName}} {{LastName}}",
+        address: "{{Street}} {{HouseNr}}",
+        country: "{{Country}}",
+        postalCode: "{{ZIP}}",
+      },
+      mergeVariables: {
+        name: "{{FirstName}}",
+        coupon: "{{Coupon}}",
+      },
+    },
+    template: template,
+    file: file,
+    finish: Finish.GLOSSY,
+  });
+});
+
+afterAll(async function () {
+  await template.delete();
+});
+
+describe("getTemplate", function () {
+  it("should get the template", async function () {
+    // arrange
+
+    // act
+    const temp = await order.getTemplate();
+
+    // assert
+    expect(temp).toBeInstanceOf(Template);
+    expect(temp.id).toEqual(template.id);
+  });
+});
+
+describe("refresh", function () {
+  it("should refresh the csv order", async function () {
+    // precondition
+    expect(order.status).toEqual(CsvStatus.order_created);
+
+    // arrange
+
+    // act
+    while (order.status === CsvStatus.order_created) {
+      await order.refresh();
+      await sleep(1000);
+    }
+
+    // assert
+    expect(order.status).not.toEqual(CsvStatus.order_created);
+  }, 30000);
+});
+
+describe("getOrders", function () {
+  it("should get orders generated by the csv", async function () {
+    // arrange
+
+    // act
+    while (await order.getOrders({}).then((x) => x.data.length > 0)) {
+      await order.refresh();
+      await sleep(1000);
+    }
+
+    const totalOrders = order.totalOrderCount;
+    const failedOrderCount = order.failedOrderCount;
+    const processedOrderCount = order.processedOrderCount;
+
+    const orders = await order.getOrders({ page: 1, limit: 200 });
+
+    // assert
+    expect(orders).toBeInstanceOf(PaginatedResponse);
+    expect(orders.data.length).toBe(totalOrders);
+    expect(
+      orders.data.filter((x) => x.status === Status.order_failed).length,
+    ).toBe(failedOrderCount);
+    expect(
+      orders.data.filter((x) => x.status !== Status.order_failed).length,
+    ).toBe(processedOrderCount);
+  }, 30_000);
+});
diff --git a/test/PrintOne.spec.ts b/test/PrintOne.spec.ts
index 65ffd10..0364a37 100644
--- a/test/PrintOne.spec.ts
+++ b/test/PrintOne.spec.ts
@@ -1,9 +1,13 @@
 import {
   Address,
   Company,
+  CreateCsvOrder,
+  CsvOrder,
+  CsvStatus,
   CustomFile,
   Finish,
   Format,
+  FriendlyCsvStatus,
   FriendlyStatus,
   Order,
   PaginatedResponse,
@@ -662,6 +666,149 @@ describe("createOrder", function () {
   });
 });
 
+describe("createCsvOrder", function () {
+  const exampleAddress: Address = {
+    name: "Test",
+    address: "Test 1",
+    addressLine2: undefined,
+    postalCode: "1234 AB",
+    city: "Test",
+    country: "NL",
+  };
+  let file: ArrayBuffer = null as unknown as ArrayBuffer;
+  const mapping: CreateCsvOrder["mapping"] = {
+    recipient: {
+      city: "{{City}}",
+      name: "{{FirstName}} {{LastName}}",
+      address: "{{Street}} {{HouseNr}}",
+      country: "{{Country}}",
+      postalCode: "{{ZIP}}",
+    },
+  };
+
+  beforeAll(() => {
+    file = fs.readFileSync(path.join(__dirname, "assets/test.csv"));
+  });
+
+  it("should create a csv order", async function () {
+    // arrange
+
+    // act
+    const csvOrder = await client.createCsvOrder({
+      mapping: mapping,
+      template: template,
+      finish: Finish.GLOSSY,
+      file: file,
+    });
+
+    // assert
+    expect(csvOrder).toBeDefined();
+    expect(csvOrder).toEqual(expect.any(CsvOrder));
+  });
+
+  it("should create a csv order with all fields", async function () {
+    // arrange
+
+    // act
+    const csvOrder = await client.createCsvOrder({
+      mapping: mapping,
+      template: template,
+      file: file,
+    });
+
+    // assert
+    expect(csvOrder).toBeDefined();
+    expect(csvOrder.id).toEqual(expect.any(String));
+    expect(csvOrder.status).toEqual(expect.any(String));
+    expect(csvOrder.createdAt).toEqual(expect.any(Date));
+    expect(csvOrder.updatedAt).toEqual(expect.any(Date));
+    // if sendDate is undefined, it should be today
+    expect(csvOrder.sendDate.getDay()).toEqual(new Date().getDay());
+    expect(csvOrder.friendlyStatus).toEqual(expect.any(String));
+    expect(csvOrder.sender).toEqual(undefined);
+    expect(csvOrder.recipientMapping).toEqual(mapping.recipient);
+    expect(csvOrder.templateId).toEqual(template.id);
+    expect(csvOrder.mergeVariableMapping).toEqual(mapping.mergeVariables);
+    expect(csvOrder.billingId).toEqual(undefined);
+    expect(csvOrder.finish).toEqual(expect.any(String));
+    expect(csvOrder.format).toEqual(expect.any(String));
+    expect(csvOrder.isBillable).toEqual(expect.any(Boolean));
+    expect(csvOrder.estimatedOrderCount).toEqual(expect.any(Number));
+    expect(csvOrder.failedOrderCount).toEqual(expect.any(Number));
+    expect(csvOrder.processedOrderCount).toEqual(expect.any(Number));
+    expect(csvOrder.totalOrderCount).toEqual(expect.any(Number));
+  });
+
+  it("should create a csv order with a billing id", async function () {
+    // arrange
+    const billingId = "test";
+
+    // act
+    const order = await client.createCsvOrder({
+      mapping: mapping,
+      template: template,
+      file: file,
+      billingId: billingId,
+    });
+
+    // assert
+    expect(order).toBeDefined();
+    expect(order.billingId).toEqual(billingId);
+  });
+
+  it("should create a csv order with a finish", async function () {
+    // arrange
+    const finish = Finish.MATTE;
+
+    // act
+    const order = await client.createCsvOrder({
+      mapping: mapping,
+      template: template,
+      finish: finish,
+      file: file,
+    });
+
+    // assert
+    expect(order).toBeDefined();
+    expect(order.finish).toEqual(finish);
+  });
+
+  it("should create a csv order with a sender", async function () {
+    // arrange
+    const sender = exampleAddress;
+
+    // act
+    const order = await client.createCsvOrder({
+      mapping: mapping,
+      template: template,
+      finish: Finish.GLOSSY,
+      file: file,
+      sender: sender,
+    });
+
+    // assert
+    expect(order).toBeDefined();
+    expect(order.sender).toEqual(sender);
+  });
+
+  it("should create a csv order with templateId", async function () {
+    // arrange
+    const templateId = template.id;
+
+    // act
+    const order = await client.createCsvOrder({
+      mapping: mapping,
+      template: templateId,
+      finish: Finish.GLOSSY,
+      file: file,
+    });
+
+    // assert
+    expect(order).toBeDefined();
+    expect(order.templateId).toEqual(templateId);
+  });
+});
+
 describe("getOrder", function () {
   let orderId: string = null as unknown as string;
 
@@ -763,12 +910,12 @@ describe("getOrders", function () {
     // assert
     expect(order).toBeDefined();
     expect(order.id).toEqual(expect.any(String));
-    expect(order.status).toEqual(expect.any(String));
+    expect(order.status).toEqual(CsvStatus.order_created);
     expect(order.createdAt).toEqual(expect.any(Date));
     expect(order.updatedAt).toEqual(expect.any(Date));
     // if sendDate is undefined, it should be today
     expect(order.sendDate.getDay()).toEqual(new Date().getDay());
-    expect(order.friendlyStatus).toEqual(expect.any(String));
+    expect(order.friendlyStatus).toEqual(FriendlyCsvStatus.order_created);
     expect(order.sender).toEqual(undefined);
     expect(order.recipient).toEqual(expect.any(Object));
     expect(order.templateId).toEqual(expect.any(String));
diff --git a/test/assets/test.csv b/test/assets/test.csv
new file mode 100644
index 0000000..2c3d978
--- /dev/null
+++ b/test/assets/test.csv
@@ -0,0 +1,3 @@
+FirstName,LastName,Street,HouseNr,ZIP,City,Country,Coupon
+John,Doe,Main Street,123,1234 AB,Anytown,Nederland,some123
+Jane,Doe,2nd Street,123,8765 ZX,Unknowntown,Nederland,some321
\ No newline at end of file