From 809f1204b6b6a3adc3e60ec13955e0c638e1a44c Mon Sep 17 00:00:00 2001
From: Nick Playfair <842413+nplayfair@users.noreply.github.com>
Date: Fri, 13 Jun 2025 22:02:55 +0100
Subject: [PATCH] Refactored tests

---
 test/index.test.js | 242 +++++++++++++++++++++++----------------------
 1 file changed, 125 insertions(+), 117 deletions(-)

diff --git a/test/index.test.js b/test/index.test.js
index 626f710..a7fff95 100644
--- a/test/index.test.js
+++ b/test/index.test.js
@@ -18,13 +18,21 @@ const noTempConfig = {
   imgDir: path.join(__dirname, 'tmp'),
 };
 const tmpNotExist = {
-  tmpDir: path.join(__dirname, 'layers', 'InvalidFolderName'),
+  tmpDir: path.join(__dirname, 'InvalidFolderName'),
   imgDir: path.join(__dirname, 'tmp'),
 };
+const imgNotExist = {
+  tmpDir: path.join(__dirname, 'tmp'),
+  imgDir: path.join(__dirname, 'InvalidFolderName'),
+};
 const tmpBadPerms = {
   tmpDir: path.join(__dirname, 'badPerms'),
   imgDir: path.join(__dirname, 'tmp'),
 };
+const imgBadPerms = {
+  tmpDir: path.join(__dirname, 'tmp'),
+  imgDir: path.join(__dirname, 'badPerms'),
+};
 const noImageConfig = {
   tmpDir: path.join(__dirname, 'tmp'),
   imgDir: emptyFolder,
@@ -57,136 +65,136 @@ const fileProcNoImage = new ImageGenerator(
 
 // Test constructor
 describe('Creating an ImageGenerator object', () => {
+  const imgGen = new ImageGenerator(folderConfig, imgConfig);
   test('should create a valid object when passed the correct files and configuration', () => {
-    const imgGen = new ImageGenerator(folderConfig, imgConfig);
     expect(imgGen).toBeInstanceOf(ImageGenerator);
-    // Image processing configuration
+  });
+  // Image processing configuration
+  test('image width should be 600', () => {
     expect(imgGen.imgConfig.resizeWidth).toBe(600);
+  });
+  test('image density should be 1000', () => {
     expect(imgGen.imgConfig.density).toBe(1000);
+  });
+  test('image compression level should be 1', () => {
     expect(imgGen.imgConfig.compLevel).toBe(1);
-    // Folders
+  });
+  test('folders should be the ones specified in the folder config parameter', () => {
     expect(imgGen.tmpDir).toBe(path.join(__dirname, 'tmp'));
     expect(imgGen.imgDir).toBe(path.join(__dirname, 'tmp'));
   });
 });
 
-// test('Create ImageGenerator object with the passed in config values', () => {
-//   const imgGen = new ImageGenerator(folderConfig, imgConfig);
-//   expect(imgGen).toBeInstanceOf(ImageGenerator);
-//   // Image processing configuration
-//   expect(imgGen.imgConfig.resizeWidth).toBe(600);
-//   expect(imgGen.imgConfig.density).toBe(1000);
-//   expect(imgGen.imgConfig.compLevel).toBe(1);
-//   // Folders
-//   expect(imgGen.tmpDir).toBe(path.join(__dirname, 'tmp'));
-//   expect(imgGen.imgDir).toBe(path.join(__dirname, 'tmp'));
-// });
-
-// Test invalid folders passed to constructor
-test('Create ImageGenerator object with invalid tmp folder', () => {
-  expect(() => {
-    new ImageGenerator(tmpNotExist, imgConfig);
-  }).toThrow();
-});
-//TODO invalid image
-
-// Test invalid folder permissions
-test('Try tmp folder with bad permissions', () => {
-  expect(() => {
-    new ImageGenerator(tmpBadPerms, imgConfig);
-  }).toThrow();
+// Testing folder config
+describe('Passing in', () => {
+  test('a non-existent tmp folder should throw error', () => {
+    expect(() => {
+      new ImageGenerator(tmpNotExist, imgConfig);
+    }).toThrow();
+  });
+  test('a tmp folder with invalid permissions should throw error', () => {
+    expect(() => {
+      new ImageGenerator(tmpBadPerms, imgConfig);
+    }).toThrow();
+  });
+  test('a non-existent img folder should throw error', () => {
+    expect(() => {
+      new ImageGenerator(imgNotExist, imgConfig);
+    }).toThrow();
+  });
+  test('an img folder with invalid permissions should throw error', () => {
+    expect(() => {
+      new ImageGenerator(imgBadPerms, imgConfig);
+    }).toThrow();
+  });
 });
 
-// getLayers
-test('Promise of an array of layers from a given folder', () => {
-  expect.assertions(1);
-  return ImageGenerator.getLayers(testLayers, layerNames).then((data) => {
-    expect(data).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          filename: expect.any(String),
-          gerber: expect.any(fs.ReadStream),
-        }),
-      ]),
+// Testing static methods
+describe('Getting layers', () => {
+  test('should return a promise of array layers', () => {
+    expect.assertions(1);
+    return ImageGenerator.getLayers(testLayers, layerNames).then((data) => {
+      expect(data).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            filename: expect.any(String),
+            gerber: expect.any(fs.ReadStream),
+          }),
+        ]),
+      );
+    });
+  });
+  test('should reject promise with error if the layers folder is not valid', () => {
+    expect.assertions(1);
+    return expect(
+      ImageGenerator.getLayers('./invalid_folder', layerNames),
+    ).rejects.toThrow(new Error('Layers folder does not exist.'));
+  });
+  test('should reject promise with error if there is not the correct number of layers', () => {
+    expect.assertions(1);
+    return expect(
+      ImageGenerator.getLayers(emptyFolder, layerNames),
+    ).rejects.toThrow(new Error('Layer not found.'));
+  });
+});
+
+describe('When extracting an archive', () => {
+  test('a non-existent archive should throw an error', () => {
+    expect(() =>
+      ImageGenerator.extractArchive(
+        'invalid.zip',
+        folderConfig.tmpDir,
+      ).toThrow(),
+    );
+  });
+  test('if the temp dir does not exist it should throw an error', () => {
+    expect(() =>
+      ImageGenerator.extractArchive(testGerber, './invalid_dir').toThrow(Error),
+    );
+  });
+  test('it should extract archive and resolve with the number of files extracted', () => {
+    expect(() =>
+      ImageGenerator.extractArchive(testGerber, folderConfig.tmpDir).toBe(12),
     );
   });
 });
 
-test('Non-existent folder should reject promise with error', () => {
-  expect.assertions(1);
-  return expect(
-    ImageGenerator.getLayers('./invalid_folder', layerNames),
-  ).rejects.toThrow(new Error('Layers folder does not exist.'));
-});
-
-test('Folder with incorrect number of layers should reject promise with error', () => {
-  expect.assertions(1);
-  return expect(
-    ImageGenerator.getLayers(emptyFolder, layerNames),
-  ).rejects.toThrow(new Error('Layer not found.'));
-});
-
-// extractArchive
-test('Non-existent archive should throw an error', () => {
-  expect(() =>
-    ImageGenerator.extractArchive('invalid.zip', folderConfig.tmpDir).toThrow(
-      Error,
-    ),
-  );
-});
-
-test('Temp dir not existing should throw an error', () => {
-  expect(() =>
-    ImageGenerator.extractArchive(testGerber, './invalid_dir').toThrow(Error),
-  );
-});
-
-test('Should extract archive and resolve with the number of files extracted', () => {
-  expect(() =>
-    ImageGenerator.extractArchive(testGerber, folderConfig.tmpDir).toBe(12),
-  );
-});
-
-// gerberToImage
-test('Temp dir not existing should throw an error', () => {
-  expect(() =>
-    fileProcNoTemp
-      .gerberToImage(testGerber)
-      .toThrow(new Error('Temporary folder does not exist.')),
-  );
-});
-
-test('Output dir not existing should throw an error', () => {
-  expect(() =>
-    fileProcNoImage
-      .gerberToImage(testGerber)
-      .toThrow(new Error('Output folder does not exist.')),
-  );
-});
-
-test('Invalid archive file should throw an error', () => {
-  expect(() =>
-    fileProc
-      .gerberToImage('invalid.zip')
-      .toThrow(new Error('Archive does not exist.')),
-  );
-});
-
-test('Archive with incomplete set of layers should throw an error', () => {
-  expect(() => fileProc.gerberToImage(incompleteGerber).toThrow(Error));
-});
-
-test('Gerber archive should resolve promise and return a filename of an image', () => {
-  expect.assertions(1);
-  return expect(fileProc.gerberToImage(testGerber)).resolves.toEqual(
-    expect.stringContaining('Arduino-Pro-Mini.png'),
-  );
-});
-
-// gerberToStream
-test('Gerber archive should resolve promise and return a png stream', () => {
-  expect.assertions(1);
-  return expect(fileProc.gerberToStream(testGerber)).resolves.toBeInstanceOf(
-    Readable,
-  );
+// Gerber methods
+describe('Converting a gerber to an image', () => {
+  test('temp dir not existing should throw an error', () => {
+    expect(() =>
+      fileProcNoTemp
+        .gerberToImage(testGerber)
+        .toThrow(new Error('Temporary folder does not exist.')),
+    );
+  });
+  test('output dir not existing should throw an error', () => {
+    expect(() =>
+      fileProcNoImage
+        .gerberToImage(testGerber)
+        .toThrow(new Error('Output folder does not exist.')),
+    );
+  });
+  test('invalid archive file should throw an error', () => {
+    expect(() =>
+      fileProc
+        .gerberToImage('invalid.zip')
+        .toThrow(new Error('Archive does not exist.')),
+    );
+  });
+  test('an archive with incomplete set of layers should throw an error', () => {
+    expect(() => fileProc.gerberToImage(incompleteGerber).toThrow(Error));
+  });
+  test('gerber archive should resolve promise and return a filename of an image', () => {
+    expect.assertions(1);
+    return expect(fileProc.gerberToImage(testGerber)).resolves.toEqual(
+      expect.stringContaining('Arduino-Pro-Mini.png'),
+    );
+  });
+  test('Gerber archive should resolve promise and return a png stream', () => {
+    expect.assertions(1);
+    return expect(fileProc.gerberToStream(testGerber)).resolves.toBeInstanceOf(
+      Readable,
+    );
+  });
 });