start refactoring tests

test/index.test.js

@@ -17,6 +17,14 @@ const noTempConfig = {
   tmpDir: emptyFolder,
   imgDir: path.join(__dirname, 'tmp'),
 };
+const tmpNotExist = {
+  tmpDir: path.join(__dirname, 'layers', 'InvalidFolderName'),
+  imgDir: path.join(__dirname, 'tmp'),
+};
+const tmpBadPerms = {
+  tmpDir: path.join(__dirname, 'badPerms'),
+  imgDir: path.join(__dirname, 'tmp'),
+};
 const noImageConfig = {
   tmpDir: path.join(__dirname, 'tmp'),
   imgDir: emptyFolder,
@@ -37,24 +45,57 @@ const layerNames = [
 
 const fileProc = new ImageGenerator(folderConfig, imgConfig, layerNames);
 const fileProcNoTemp = new ImageGenerator(noTempConfig, imgConfig, layerNames);
-const fileProcNoImage = new ImageGenerator(noImageConfig, imgConfig, layerNames);
+const fileProcNoImage = new ImageGenerator(
+  noImageConfig,
+  imgConfig,
+  layerNames,
+);
 
 /**************
  * Tests
  ***************/
 
 // Test constructor
-test('Create ImageGenerator object with the passed in config values', () => {
+describe('Creating an ImageGenerator object', () => {
-  const imgGen = new ImageGenerator(folderConfig, imgConfig);
+  test('should create a valid object when passed the correct files and configuration', () => {
-  expect(imgGen).toBeInstanceOf(ImageGenerator);
+    const imgGen = new ImageGenerator(folderConfig, imgConfig);
-  // Image processing configuration
+    expect(imgGen).toBeInstanceOf(ImageGenerator);
-  expect(imgGen.imgConfig.resizeWidth).toBe(600);
+    // Image processing configuration
-  expect(imgGen.imgConfig.density).toBe(1000);
+    expect(imgGen.imgConfig.resizeWidth).toBe(600);
-  expect(imgGen.imgConfig.compLevel).toBe(1);
+    expect(imgGen.imgConfig.density).toBe(1000);
-  // Folders
+    expect(imgGen.imgConfig.compLevel).toBe(1);
-  expect(imgGen.tmpDir).toBe(path.join(__dirname, 'tmp'));
+    // Folders
-  expect(imgGen.imgDir).toBe(path.join(__dirname, 'tmp'));
+    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();
+});
 
 // getLayers
 test('Promise of an array of layers from a given folder', () => {
@@ -66,40 +107,44 @@ test('Promise of an array of layers from a given folder', () => {
           filename: expect.any(String),
           gerber: expect.any(fs.ReadStream),
         }),
-      ])
+      ]),
     );
   });
 });
 
 test('Non-existent folder should reject promise with error', () => {
   expect.assertions(1);
-  return expect(ImageGenerator.getLayers('./invalid_folder', layerNames)).rejects.toThrow(
+  return expect(
-    new Error('Layers folder does not exist.')
+    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(
+  return expect(
-    new Error('Layer not found.')
+    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)
+    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)
+    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));
+  expect(() =>
+    ImageGenerator.extractArchive(testGerber, folderConfig.tmpDir).toBe(12),
+  );
 });
 
 // gerberToImage
@@ -107,7 +152,7 @@ test('Temp dir not existing should throw an error', () => {
   expect(() =>
     fileProcNoTemp
       .gerberToImage(testGerber)
-      .toThrow(new Error('Temporary folder does not exist.'))
+      .toThrow(new Error('Temporary folder does not exist.')),
   );
 });
 
@@ -115,7 +160,7 @@ test('Output dir not existing should throw an error', () => {
   expect(() =>
     fileProcNoImage
       .gerberToImage(testGerber)
-      .toThrow(new Error('Output folder does not exist.'))
+      .toThrow(new Error('Output folder does not exist.')),
   );
 });
 
@@ -123,29 +168,25 @@ test('Invalid archive file should throw an error', () => {
   expect(() =>
     fileProc
       .gerberToImage('invalid.zip')
-      .toThrow(new Error('Archive does not exist.'))
+      .toThrow(new Error('Archive does not exist.')),
   );
 });
 
 test('Archive with incomplete set of layers should throw an error', () => {
-  expect(() =>
+  expect(() => fileProc.gerberToImage(incompleteGerber).toThrow(Error));
-    fileProc
-      .gerberToImage(incompleteGerber)
-      .toThrow(Error)
-  );
 });
 
 test('Gerber archive should resolve promise and return a filename of an image', () => {
   expect.assertions(1);
-  return expect(
+  return expect(fileProc.gerberToImage(testGerber)).resolves.toEqual(
-    fileProc.gerberToImage(testGerber)
+    expect.stringContaining('Arduino-Pro-Mini.png'),
-  ).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(
+  return expect(fileProc.gerberToStream(testGerber)).resolves.toBeInstanceOf(
-    fileProc.gerberToStream(testGerber)
+    Readable,
-  ).resolves.toBeInstanceOf(Readable);
+  );
 });