Refactored tests

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', () => {
+// Testing folder config
-//   const imgGen = new ImageGenerator(folderConfig, imgConfig);
+describe('Passing in', () => {
-//   expect(imgGen).toBeInstanceOf(ImageGenerator);
+  test('a non-existent tmp folder should throw error', () => {
-//   // Image processing configuration
+    expect(() => {
-//   expect(imgGen.imgConfig.resizeWidth).toBe(600);
+      new ImageGenerator(tmpNotExist, imgConfig);
-//   expect(imgGen.imgConfig.density).toBe(1000);
+    }).toThrow();
-//   expect(imgGen.imgConfig.compLevel).toBe(1);
+  });
-//   // Folders
+  test('a tmp folder with invalid permissions should throw error', () => {
-//   expect(imgGen.tmpDir).toBe(path.join(__dirname, 'tmp'));
+    expect(() => {
-//   expect(imgGen.imgDir).toBe(path.join(__dirname, 'tmp'));
+      new ImageGenerator(tmpBadPerms, imgConfig);
-// });
+    }).toThrow();
-
+  });
-// Test invalid folders passed to constructor
+  test('a non-existent img folder should throw error', () => {
-test('Create ImageGenerator object with invalid tmp folder', () => {
+    expect(() => {
-  expect(() => {
+      new ImageGenerator(imgNotExist, imgConfig);
-    new ImageGenerator(tmpNotExist, imgConfig);
+    }).toThrow();
-  }).toThrow();
+  });
-});
+  test('an img folder with invalid permissions should throw error', () => {
-//TODO invalid image
+    expect(() => {
-
+      new ImageGenerator(imgBadPerms, imgConfig);
-// Test invalid folder permissions
+    }).toThrow();
-test('Try tmp folder with bad permissions', () => {
+  });
-  expect(() => {
-    new ImageGenerator(tmpBadPerms, imgConfig);
-  }).toThrow();
 });
 
-// getLayers
+// Testing static methods
-test('Promise of an array of layers from a given folder', () => {
+describe('Getting layers', () => {
-  expect.assertions(1);
+  test('should return a promise of array layers', () => {
-  return ImageGenerator.getLayers(testLayers, layerNames).then((data) => {
+    expect.assertions(1);
-    expect(data).toEqual(
+    return ImageGenerator.getLayers(testLayers, layerNames).then((data) => {
-      expect.arrayContaining([
+      expect(data).toEqual(
-        expect.objectContaining({
+        expect.arrayContaining([
-          filename: expect.any(String),
+          expect.objectContaining({
-          gerber: expect.any(fs.ReadStream),
+            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', () => {
+// Gerber methods
-  expect.assertions(1);
+describe('Converting a gerber to an image', () => {
-  return expect(
+  test('temp dir not existing should throw an error', () => {
-    ImageGenerator.getLayers('./invalid_folder', layerNames),
+    expect(() =>
-  ).rejects.toThrow(new Error('Layers folder does not exist.'));
+      fileProcNoTemp
-});
+        .gerberToImage(testGerber)
-
+        .toThrow(new Error('Temporary folder does not exist.')),
-test('Folder with incorrect number of layers should reject promise with error', () => {
+    );
-  expect.assertions(1);
+  });
-  return expect(
+  test('output dir not existing should throw an error', () => {
-    ImageGenerator.getLayers(emptyFolder, layerNames),
+    expect(() =>
-  ).rejects.toThrow(new Error('Layer not found.'));
+      fileProcNoImage
-});
+        .gerberToImage(testGerber)
-
+        .toThrow(new Error('Output folder does not exist.')),
-// extractArchive
+    );
-test('Non-existent archive should throw an error', () => {
+  });
-  expect(() =>
+  test('invalid archive file should throw an error', () => {
-    ImageGenerator.extractArchive('invalid.zip', folderConfig.tmpDir).toThrow(
+    expect(() =>
-      Error,
+      fileProc
-    ),
+        .gerberToImage('invalid.zip')
-  );
+        .toThrow(new Error('Archive does not exist.')),
-});
+    );
-
+  });
-test('Temp dir not existing should throw an error', () => {
+  test('an archive with incomplete set of layers should throw an error', () => {
-  expect(() =>
+    expect(() => fileProc.gerberToImage(incompleteGerber).toThrow(Error));
-    ImageGenerator.extractArchive(testGerber, './invalid_dir').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(
-test('Should extract archive and resolve with the number of files extracted', () => {
+      expect.stringContaining('Arduino-Pro-Mini.png'),
-  expect(() =>
+    );
-    ImageGenerator.extractArchive(testGerber, folderConfig.tmpDir).toBe(12),
+  });
-  );
+  test('Gerber archive should resolve promise and return a png stream', () => {
-});
+    expect.assertions(1);
-
+    return expect(fileProc.gerberToStream(testGerber)).resolves.toBeInstanceOf(
-// gerberToImage
+      Readable,
-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,
-  );
 });