added validation

Author: sylvesterdas

index.js

@@ -1,15 +1,22 @@
 "use strict";
 
 const { CeaserCipherTransform } = require("./cipher");
+const {
+  ensureValidForBuffer,
+  ensureValidForString,
+  ensureValidKey,
+} = require("./validate");
 
 /**
  * Encrypt a string using Caesar Cipher
- * 
+ *
  * @param {string} str
  * @param {number} key
  * @returns string
  */
 function encryptString(str, key) {
+  ensureValidForString(str, key);
+
   return str
     .split("")
     .map((s) => s.charCodeAt(0) + (key % 26))
@@ -19,12 +26,14 @@ function encryptString(str, key) {
 
 /**
  * Decrypt a string using Caesar Cipher
- * 
+ *
  * @param {string} str
  * @param {number} key
  * @returns string
  */
 function decryptString(str, key) {
+  ensureValidForString(str, key);
+
   return str
     .split("")
     .map((s) => s.charCodeAt(0) - (key % 26))
@@ -34,61 +43,59 @@ function decryptString(str, key) {
 
 /**
  * Encrypt a buffer array using Caesar Cipher
- * 
+ *
  * @param {Buffer} buffer
  * @param {number} key
  * @returns buffer
  */
 function encrypt(buffer, key) {
-    return buffer
-        .map((byte) => byte + (key % 26));
+  ensureValidForBuffer(buffer, key);
+  return buffer.map((byte) => byte + (key % 26));
 }
 
 /**
  * Decrypt a buffer array using Caesar Cipher
- * 
+ *
  * @param {Buffer} buffer
  * @param {number} key
  * @returns buffer
  */
 function decrypt(buffer, key) {
-    return buffer
-        .map((byte) => byte - (key % 26));
+  ensureValidForBuffer(buffer, key);
+  return buffer.map((byte) => byte - (key % 26));
 }
 
-
 class EncryptTransform extends CeaserCipherTransform {
-
-    /**
-     * Transform stream for encryption using Caesar Cipher
-     * 
-     * @param {number} key Encryption key
-     */
-    constructor(key) {
-        super();
-        this.key = key;
-    }
+  /**
+   * Transform stream for encryption using Caesar Cipher
+   *
+   * @param {number} key Encryption key
+   */
+  constructor(key) {
+    super();
+    ensureValidKey(key);
+    this.key = key;
+  }
 }
 
 class DecryptTransform extends CeaserCipherTransform {
-
-    /**
-     * Transform stream for decryption using Caesar Cipher
-     * 
-     * @param {number} key Decryption key
-     */
-    constructor(key) {
-        super();
-        this.key = -key;
-    }
+  /**
+   * Transform stream for decryption using Caesar Cipher
+   *
+   * @param {number} key Decryption key
+   */
+  constructor(key) {
+    super();
+    ensureValidKey(key);
+    this.key = -key;
+  }
 }
 
 module.exports = {
-    encrypt,
-    decrypt,
-    encryptString,
-    decryptString,
-    EncryptTransform,
-    DecryptTransform
-}
-
+  encrypt,
+  decrypt,
+  encryptString,
+  decryptString,
+  EncryptTransform,
+  DecryptTransform,
+};

test/empty.txt

@@ -0,0 +1,85 @@
+const {
+  encrypt,
+  decrypt,
+  encryptString,
+  decryptString,
+  EncryptTransform,
+  DecryptTransform,
+} = require("..");
+const fs = require("fs");
+const readFile = require('util').promisify(fs.readFile);
+const path = require("path");
+const assert = require("assert");
+const { after } = require("mocha");
+
+const emptyFile = path.join(__dirname, "./empty.txt");
+const inputFile = path.join(__dirname, "./test.txt");
+const outputFile = path.join(__dirname, "./output1.txt");
+
+describe("@gykh/caesar-cipher", function () {
+  describe("Validaton", function () {
+    it("should throw error for empty file", async function () {
+      const data = await readFile(emptyFile);
+      assert.throws(() => encrypt(data, 3));
+      assert.throws(() => decrypt(data, 3));
+    });
+    it("should throw error for invalid data", function () {
+      const data = undefined;
+      assert.throws(() => encrypt(data, 3));
+      assert.throws(() => decrypt(data, 3));
+    });
+    it("should throw error for empty string", function () {
+      const data = "";
+      assert.throws(() => encryptString(data, 3));
+      assert.throws(() => decryptString(data, 3));
+    });
+    it("should throw error for long string", function () {
+      const data = makeString(1001);
+      assert.throws(() => encryptString(data, 3));
+      assert.throws(() => decryptString(data, 3));
+    });
+    it("should throw error for no/invalid key", function () {
+      const data = "test";
+      assert.throws(() => encryptString(data));
+      assert.throws(() => encryptString(data, 'sa'));
+      assert.throws(() => decryptString(data));
+      assert.throws(() => decryptString(data, 'sa'));
+      assert.throws(() => decryptString(data, 26));
+      assert.throws(() => decryptString(data, -1));
+    });
+    it("should throw error for invalid transform key", function () {
+      assert.throws(() => new EncryptTransform());
+      assert.throws(() => new EncryptTransform("as"));
+      assert.throws(() => new DecryptTransform());
+      assert.throws(() => new DecryptTransform("as"));
+      assert.throws(() => new DecryptTransform(26));
+      assert.throws(() => new DecryptTransform(-1));
+    });
+    it("should throw error for invalid transform", function (done) {      
+      const encTransform = new EncryptTransform(3);
+      const decTransform = new DecryptTransform(3);
+
+      const stream = fs.createReadStream(emptyFile)
+        .pipe(encTransform)
+        .pipe(decTransform)
+        .pipe(fs.createWriteStream(outputFile));
+
+      stream.on("error", (err) => assert.ok(false, err.message));
+      stream.on("finish", done);
+    });
+
+    after(() => {
+      if (fs.existsSync(outputFile)) {
+        fs.unlinkSync(outputFile);
+      }
+    });
+  });
+});
+
+function makeString(/** @type {number} */ minLength) {
+  var result           = 'a';
+  while (result.length < minLength) {
+    result += result;
+  }
+  return result;
+}

test/validations.test.js

@@ -0,0 +1,66 @@
+/**
+ * Check for valid key
+ * 
+ * @param {number} key Shift key
+ */
+function ensureValidKey(key) {
+    if (!key) {
+        throw new Error("Key is required");
+    }
+
+    if (typeof key !== 'number') {
+        throw new Error("Key should be a number")
+    }
+    
+    if (0 > key || key > 25) {
+        throw new Error("Key should be within the range of 0 - 25");
+    }
+}
+
+/**
+ * Validation for encryptString and decryptString
+ * 
+ * @param {String} str String input value
+ * @param {number} key Shift key
+ */
+function ensureValidForString (str, key) {
+    if (!str) {
+        throw new Error("Str is required");
+    }
+
+    if (typeof str !== 'string' || str.length === 0) {
+        throw new Error("Str is invalid");
+    }
+    
+    if (str.length > 1000) {
+        throw new Error("Input too large, use EncryptTransform / DecryptTransform instead");
+    }
+
+    ensureValidKey(key);
+}
+
+/**
+ * Validation for encrypt and decrypt functions
+ * 
+ * @param {Buffer} buffer Buffer input value
+ * @param {number} key Shift key
+ */
+function ensureValidForBuffer (buffer, key) {
+    if (!buffer) {
+        throw new Error("Buffer is required");
+    }
+
+    if (!(buffer instanceof Buffer) || buffer.length === 0) {
+        throw new Error("Buffer is invalid");
+    }
+    
+    if (buffer.length > 1000) {
+        throw new Error("Input too large, use EncryptTransform / DecryptTransform instead");
+    }
+}
+
+module.exports = {
+    ensureValidKey,
+    ensureValidForString,
+    ensureValidForBuffer
+}