Removed repeated code in createPass and added few tests and moved few tests from index.ts to new factory test file

spec/factory.ts

@@ -0,0 +1,97 @@
+import { createPass } from "../lib/factory";
+import formatMessage from "../lib/messages";
+import * as fs from "fs";
+import * as path from "path";
+
+describe("createPass", () => {
+	it("should throw if first argument is not provided", async () => {
+		await expectAsync(createPass(undefined)).toBeRejectedWithError(
+			formatMessage("CP_NO_OPTS")
+		);
+	});
+
+	try {
+		let certificatesPath = "../certificates";
+
+		try {
+			fs.accessSync(path.resolve(__dirname, certificatesPath));
+		} catch (err) {
+			certificatesPath = "../certs";
+
+			try {
+				fs.accessSync(path.resolve(__dirname, certificatesPath));
+			} catch (err) {
+				certificatesPath = "";
+			}
+		}
+
+		if (certificatesPath) {
+			it("should return a pass instance", async () => {
+				await expectAsync(createPass({
+					model: path.resolve(__dirname, "../examples/models/exampleBooking.pass"),
+					certificates: {
+						signerCert: path.resolve(__dirname, certificatesPath, "./signerCert.pem"),
+						signerKey: {
+							keyFile: path.resolve(__dirname, certificatesPath, "./signerKey.pem"),
+							passphrase: "password1234"
+						},
+						wwdr: path.resolve(__dirname, certificatesPath, "./WWDR.pem"),
+					}
+				})).toBeResolved();
+			});
+
+			describe("Model validation", () => {
+				it("Should reject with non valid model", async () => {
+					await expectAsync(createPass({
+						// @ts-expect-error
+						model: 0,
+						certificates: {
+							signerCert: path.resolve(__dirname, certificatesPath, "./signerCert.pem"),
+							signerKey: {
+								keyFile: path.resolve(__dirname, certificatesPath, "./signerKey.pem"),
+								passphrase: "password1234"
+							},
+							wwdr: path.resolve(__dirname, certificatesPath, "./WWDR.pem"),
+						}
+					})).toBeRejected();
+
+					await expectAsync(createPass({
+						model: undefined,
+						certificates: {
+							signerCert: path.resolve(__dirname, certificatesPath, "./signerCert.pem"),
+							signerKey: {
+								keyFile: path.resolve(__dirname, certificatesPath, "./signerKey.pem"),
+								passphrase: "password1234"
+							},
+							wwdr: path.resolve(__dirname, certificatesPath, "./WWDR.pem"),
+						}
+					})).toBeRejected();
+
+					await expectAsync(createPass({
+						model: null,
+						certificates: {
+							signerCert: path.resolve(__dirname, certificatesPath, "./signerCert.pem"),
+							signerKey: {
+								keyFile: path.resolve(__dirname, certificatesPath, "./signerKey.pem"),
+								passphrase: "password1234"
+							},
+							wwdr: path.resolve(__dirname, certificatesPath, "./WWDR.pem"),
+						}
+					})).toBeRejected();
+
+					await expectAsync(createPass({
+						model: {},
+						certificates: {
+							signerCert: path.resolve(__dirname, certificatesPath, "./signerCert.pem"),
+							signerKey: {
+								keyFile: path.resolve(__dirname, certificatesPath, "./signerKey.pem"),
+								passphrase: "password1234"
+							},
+							wwdr: path.resolve(__dirname, certificatesPath, "./WWDR.pem"),
+						}
+					})).toBeRejected();
+				});
+			});
+		}
+	} catch (err) { }
+});

spec/index.ts

@@ -1,4 +1,5 @@
 import { createPass, Pass } from "..";
+import * as path from "path";
 
 /**
  * Tests created upon Jasmine testing suite.
@@ -8,12 +9,12 @@ describe("Passkit-generator", function () {
 	let pass: Pass;
 	beforeEach(async () => {
 		pass = await createPass({
-			model: "examples/models/examplePass.pass",
+			model: path.resolve(__dirname, "../examples/models/examplePass.pass"),
 			certificates: {
-				wwdr: "certificates/WWDR.pem",
+				wwdr: path.resolve(__dirname, "../certificates/WWDR.pem"),
-				signerCert: "certificates/signerCert.pem",
+				signerCert: path.resolve(__dirname, "../certificates/signerCert.pem"),
 				signerKey: {
-					keyFile: "certificates/signerKey.pem",
+					keyFile: path.resolve(__dirname, "../certificates/signerKey.pem"),
 					passphrase: "123456"
 				}
 			},
@@ -21,63 +22,6 @@ describe("Passkit-generator", function () {
 		});
 	});
 
-	describe("Model validation", () => {
-		it("Should reject with non valid model", async () => {
-			await expectAsync(createPass({
-				// @ts-expect-error
-				model: 0,
-				certificates: {
-					wwdr: "certificates/WWDR.pem",
-					signerCert: "certificates/signerCert.pem",
-					signerKey: {
-						keyFile: "certificates/signerKey.pem",
-						passphrase: "123456"
-					}
-				},
-				overrides: {}
-			})).toBeRejected();
-
-			await expectAsync(createPass({
-				model: undefined,
-				certificates: {
-					wwdr: "certificates/WWDR.pem",
-					signerCert: "certificates/signerCert.pem",
-					signerKey: {
-						keyFile: "certificates/signerKey.pem",
-						passphrase: "123456"
-					}
-				},
-				overrides: {}
-			})).toBeRejected();
-
-			await expectAsync(createPass({
-				model: null,
-				certificates: {
-					wwdr: "certificates/WWDR.pem",
-					signerCert: "certificates/signerCert.pem",
-					signerKey: {
-						keyFile: "certificates/signerKey.pem",
-						passphrase: "123456"
-					}
-				},
-				overrides: {}
-			})).toBeRejected();
-
-			await expectAsync(createPass({
-				model: {},
-				certificates: {
-					wwdr: "certificates/WWDR.pem",
-					signerCert: "certificates/signerCert.pem",
-					signerKey: {
-						keyFile: "certificates/signerKey.pem",
-						passphrase: "123456"
-					}
-				},
-				overrides: {}
-			})).toBeRejected();
-		});
-	});
-
 	describe("localize()", () => {
 		it("Won't apply changes without at least one parameter", () => {
 			// @ts-expect-error

src/factory.ts

@@ -1,5 +1,5 @@
 import { Pass } from "./pass";
-import { FactoryOptions, BundleUnit, FinalCertificates } from "./schema";
+import { FactoryOptions, BundleUnit, FinalCertificates, PartitionedBundle, OverridesSupportedOptions } from "./schema";
 import formatMessage from "./messages";
 import { getModelContents, readCertificatesFromOptions } from "./parser";
 import { splitBufferBundle } from "./utils";
@@ -14,7 +14,7 @@ import { AbstractModel, AbstractFactoryOptions } from "./abstract";
  */
 
 export async function createPass(
-	options: FactoryOptions | AbstractModel,
+	options: FactoryOptions | InstanceType<typeof AbstractModel>,
 	additionalBuffers?: BundleUnit,
 	abstractMissingData?: Omit<AbstractFactoryOptions, "model">
 ): Promise<Pass> {
@@ -25,6 +25,10 @@ export async function createPass(
 	try {
 		if (options instanceof AbstractModel) {
 			let certificates: FinalCertificates;
+			let overrides: OverridesSupportedOptions = {
+				...(options.overrides || {}),
+				...(abstractMissingData && abstractMissingData.overrides || {})
+			};
 
 			if (!(options.certificates && options.certificates.signerCert && options.certificates.signerKey) && abstractMissingData.certificates) {
 				certificates = Object.assign(
@@ -35,39 +39,30 @@ export async function createPass(
 				certificates = options.certificates;
 			}
 
-			if (additionalBuffers) {
+			return createPassInstance(options.bundle, certificates, overrides, additionalBuffers);
-				const [additionalL10n, additionalBundle] = splitBufferBundle(additionalBuffers);
-				Object.assign(options.bundle["l10nBundle"], additionalL10n);
-				Object.assign(options.bundle["bundle"], additionalBundle);
-			}
-
-			return new Pass({
-				model: options.bundle,
-				certificates: certificates,
-				overrides: {
-					...(options.overrides || {}),
-					...(abstractMissingData && abstractMissingData.overrides || {})
-				}
-			});
 		} else {
 			const [bundle, certificates] = await Promise.all([
 				getModelContents(options.model),
 				readCertificatesFromOptions(options.certificates)
 			]);
 
-			if (additionalBuffers) {
+			return createPassInstance(bundle, certificates, options.overrides, additionalBuffers);
-				const [additionalL10n, additionalBundle] = splitBufferBundle(additionalBuffers);
-				Object.assign(bundle["l10nBundle"], additionalL10n);
-				Object.assign(bundle["bundle"], additionalBundle);
-			}
-
-			return new Pass({
-				model: bundle,
-				certificates,
-				overrides: options.overrides
-			});
 		}
 	} catch (err) {
 		throw new Error(formatMessage("CP_INIT_ERROR", "pass", err));
 	}
 }
+
+function createPassInstance(model: PartitionedBundle, certificates: FinalCertificates, overrides: OverridesSupportedOptions, additionalBuffers?: BundleUnit) {
+	if (additionalBuffers) {
+		const [additionalL10n, additionalBundle] = splitBufferBundle(additionalBuffers);
+		Object.assign(model["l10nBundle"], additionalL10n);
+		Object.assign(model["bundle"], additionalBundle);
+	}
+
+	return new Pass({
+		model,
+		certificates,
+		overrides
+	});
+}