How to generate dummy Orders for testing

[michaelbromley]

Here's a script provided by @aroxenhag for populating test orders:

import { faker } from "@faker-js/faker/locale/en";
import {
  bootstrapWorker,
  Customer,
  CustomerService,
  Fulfillment,
  Order,
  OrderService,
  PaginatedList,
  ProductVariant,
  ProductVariantService,
  RequestContextService,
  ShippingMethodService,
  Translated,
} from "@vendure/core";
​
import { config } from "../vendure-config";
​
const vendureConfig = {
  ...config,
};
​
async function createOrders() {
  const worker = await bootstrapWorker(vendureConfig);
  const app = worker.app;
​
  const requestContextService: RequestContextService = app.get(
    RequestContextService
  );
  const shippingMethodService: ShippingMethodService = app.get(
    ShippingMethodService
  );
  const customerService: CustomerService = app.get(CustomerService);
  const orderService: OrderService = app.get(OrderService);
  const productVariantService: ProductVariantService = app.get(
    ProductVariantService
  );
  const ctx = await requestContextService.create({
    apiType: "admin",
  });
​
  // if customer id supplied from command line, use it
  const customerId = process.argv?.[2];
  let customer: Customer;
  if (customerId) {
    console.log("using customer id: ", customerId);
    customer = (await customerService.findOne(ctx, customerId)) as Customer;
  } else {
    const firstName = faker.name.firstName();
    const lastName = faker.name.lastName();
    customer = (await customerService.createOrUpdate(
      ctx,
      {
        emailAddress: faker.internet.email(firstName, lastName),
        firstName,
        lastName,
      },
      false
    )) as Customer;
  }
​
  console.log("customer", customer);
​
  const order = await orderService.createDraft(ctx);
  console.log("created order: ", order.id);
​
  const allProductVariants: PaginatedList<Translated<ProductVariant>> =
    await productVariantService.findAll(ctx);
​
  // one of each please
  for (const variant of allProductVariants.items) {
    if (variant.stockOnHand > 0) {
      await orderService.addItemToOrder(ctx, order.id, variant.id, 1);
    }
  }
​
  await orderService.addCustomerToOrder(ctx, order.id, customer);
​
  const shippingMethods = await shippingMethodService.findAll(ctx);
  await orderService.setShippingMethod(
    ctx,
    order.id,
    shippingMethods.items[0].id
  );
​
  await orderService.setShippingAddress(ctx, order.id, {
    fullName: `${customer.firstName} ${customer.lastName}`,
    streetLine1: faker.address.streetAddress(),
    city: faker.address.city(),
    countryCode: "SE",
  });
​
  await orderService.transitionToState(ctx, order.id, "ArrangingPayment");
​
  const paidOrder = await orderService.addPaymentToOrder(ctx, order.id, {
    method: "e2e-test-payment",
    metadata: {
      shouldDecline: false,
      shouldError: false,
      shouldErrorOnSettle: false,
    },
  });
  console.log(paidOrder);
​
  const fulfillment = await orderService.createFulfillment(ctx, {
    lines: (paidOrder as Order).lines.map((line) => ({
      orderLineId: line.id,
      quantity: line.quantity,
    })),
    handler: {
      code: "manual-fulfillment",
      arguments: [
        {
          name: "method",
          value: "NOT_USED",
        },
        {
          name: "trackingCode",
          value: "NOT_USED",
        },
      ],
    },
  });
  console.log(fulfillment);
​
  await orderService.transitionFulfillmentToState(
    ctx,
    (fulfillment as Fulfillment).id,
    "Delivered"
  );
}
​
createOrders()
  .then(() => process.exit(0))
  .catch((error) => {
    console.log(error);
    return process.exit(1);
  });