Linter config lints test directory (#99)

Modify eslint config to lint ./test/

packages/ripple-binary-codec/test/tx-encode-decode.test.js

@@ -1,107 +1,80 @@
-const {
-  encode,
-  decode
-} = require('../dist')
+const { encode, decode } = require("../dist");
 
 // Notice: no Amount or Fee
 const tx_json = {
-  Account: 'r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ',
+  Account: "r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ",
   // Amount: '1000',
-  Destination: 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
+  Destination: "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
   // Fee: '10',
 
   // JavaScript converts operands to 32-bit signed ints after doing bitwise
   // operations. We need to convert it back to an unsigned int with >>> 0.
-  Flags: ((1 << 31) >>> 0), // tfFullyCanonicalSig
+  Flags: (1 << 31) >>> 0, // tfFullyCanonicalSig
 
   Sequence: 1,
-  TransactionType: 'Payment'
+  TransactionType: "Payment",
   // TxnSignature,
   // Signature,
   // SigningPubKey
-}
+};
 
-const amount_parameters_message = input => {
-  // disables the ESLint rule on the whole rest of the file
-  /* eslint-disable max-len */
-  return `${input} is an illegal amount
-
-Native values must be described in drops, a million of which equal one XRP.
-This must be an integer number, with the absolute value not exceeding 100000000000000000
-
-IOU values must have a maximum precision of 16 significant digits. They are serialized as
-a canonicalised mantissa and exponent.
-
-The valid range for a mantissa is between 1000000000000000 and 9999999999999999
-The exponent must be >= -96 and <= 80
-
-Thus the largest serializable IOU value is:
-999999999999999900000000000000000000000000000000000000000000000000000000000000000000000000000000
-
-And the smallest:
-0.000000000000000000000000000000000000000000000000000000000000000000000000000000001
-`
-}
-
-describe('encoding and decoding tx_json', function () {
-  test('can encode tx_json without Amount or Fee', function () {
-    const encoded = encode(tx_json)
-    const decoded = decode(encoded)
-    expect(tx_json).toEqual(decoded)
-  })
-  test('can encode tx_json with Amount and Fee', function () {
+describe("encoding and decoding tx_json", function () {
+  test("can encode tx_json without Amount or Fee", function () {
+    const encoded = encode(tx_json);
+    const decoded = decode(encoded);
+    expect(tx_json).toEqual(decoded);
+  });
+  test("can encode tx_json with Amount and Fee", function () {
     const my_tx = Object.assign({}, tx_json, {
-      Amount: '1000',
-      Fee: '10'
-    })
-    const encoded = encode(my_tx)
-    const decoded = decode(encoded)
-    expect(my_tx).toEqual(decoded)
-  })
-  test('throws when Amount is invalid', function () {
+      Amount: "1000",
+      Fee: "10",
+    });
+    const encoded = encode(my_tx);
+    const decoded = decode(encoded);
+    expect(my_tx).toEqual(decoded);
+  });
+  test("throws when Amount is invalid", function () {
     const my_tx = Object.assign({}, tx_json, {
-      Amount: '1000.001',
-      Fee: '10'
-    })
+      Amount: "1000.001",
+      Fee: "10",
+    });
     expect(() => {
-      encode(my_tx)
-    }).toThrow()
-  })
-  test('throws when Fee is invalid', function () {
+      encode(my_tx);
+    }).toThrow();
+  });
+  test("throws when Fee is invalid", function () {
     const my_tx = Object.assign({}, tx_json, {
-      Amount: '1000',
-      Fee: '10.123'
-    })
+      Amount: "1000",
+      Fee: "10.123",
+    });
     expect(() => {
-      encode(my_tx)
-    }).toThrow()
-  })
-  test('throws when Amount and Fee are invalid', function () {
+      encode(my_tx);
+    }).toThrow();
+  });
+  test("throws when Amount and Fee are invalid", function () {
     const my_tx = Object.assign({}, tx_json, {
-      Amount: '1000.789',
-      Fee: '10.123'
-    })
+      Amount: "1000.789",
+      Fee: "10.123",
+    });
     expect(() => {
-      encode(my_tx)
-    }).toThrow()
-  })
-  test('throws when Amount is a number instead of a string-encoded integer',
-    function () {
-      const my_tx = Object.assign({}, tx_json, {
-        Amount: 1000.789
-      })
-      expect(() => {
-        encode(my_tx)
-      }).toThrow()
-    })
+      encode(my_tx);
+    }).toThrow();
+  });
+  test("throws when Amount is a number instead of a string-encoded integer", function () {
+    const my_tx = Object.assign({}, tx_json, {
+      Amount: 1000.789,
+    });
+    expect(() => {
+      encode(my_tx);
+    }).toThrow();
+  });
 
-  test('throws when Fee is a number instead of a string-encoded integer',
-    function () {
-      const my_tx = Object.assign({}, tx_json, {
-        Amount: 1234.56
-      })
-      expect(() => {
-        encode(my_tx)
-      }).toThrow()
-    })
-})
+  test("throws when Fee is a number instead of a string-encoded integer", function () {
+    const my_tx = Object.assign({}, tx_json, {
+      Amount: 1234.56,
+    });
+    expect(() => {
+      encode(my_tx);
+    }).toThrow();
+  });
+});