Mazeltov JS Utils

This is a collection of utilities for the @mazeltov project.

There are a lot of goodies in here and each one aims to be functional, unit tested, and generally applicable to solving common code problems. Nothing in here should be business logic oriented.

Sub Packages

collection

A library for manipulating arrays and objects

dev

Unit and integration test helpers.

encryption

Basic encryption helpers

error

Core error types (every error inherits the semantics of HTTP error statuses)

func

Functional helpers (currying, decorating)

logic

Functional logic helpers

map

Map values to new values

rand

CSPRNG and random values

string

String helpers

validate

Data validators

A few others

I had added some here for an original project this library was featured and may manicure these or leave them out. But am still leaning towards keeping and expanding the tools.

• ssl
• domain
• file
• process

Testing

Running a Single Test Suite

Mazeltov uses it's own unit test and integration test library. Unit tests are incredibly easy to write

const {
  dev: {
    runUnitTests,
  },
} = require('@mazeltov/util');

const logger = require('@mazeltov/logger')('test/myFunction');

const myFunctionA = (a, b) => a + b;
const myFunctionB = (a) => a.concat('mazeltov!');

runUnitTests([

  /**
  * Tests are delimited by subject under test (a function)
  * and one or more cases (array of args where last element is expected return)
  */
  myFunctionA,
  [2, 2, 4],
  [2, 3, 5],
  ['foo', 'bar', 'foobar'],

  myFunctionB,
  ['I say', 'I say mazeltov!'],
  ['You say', 'You say mazeltov!'],

], logger, require('assert'));

Chai, mocha and jest are nice frameworks but put too much burden on representing your tests with natural language. Because the unit tests rely on a return value it will encourage better code to be written (more functional style) and the syntax for testing is much simpler to remember.

Running Multiple Test Suites

Mazeltov encourages dependency injection. The recommended way to run multiple tests like above would be to follow the example at test/index.js in the util repo.

Passing in the logger and assert core library may seem like tedium but follows the principal of making everything injectable.

const assert = require('assert');

const loggerLib = require('@mazeltov/logger');

const logger = loggerLib('lib.js.util test');

const suites = process.argv.slice(2);

const suiteTestNames = {};

const suiteNames = suites.map((suitesMaybeTests) => {
  const [suite, testStr = ''] = suitesMaybeTests.split(':')
  suiteTestNames[suite] = testStr.split(',');
  return suite;
});

const runAllSuites = suiteNames.length === 0;

const {
  runUnitTests,
  runTestSuites,
} = require('../dev');

runTestSuites([
  'collection',
  'dev',
  'encryption',
  'error',
  'func',
  'logic',
  'map',
  'rand',
  'string',
  'validate',
]
.filter((suiteName) => runAllSuites || suiteNames.includes(suiteName))
.map((name) => [ name, require(`./${name}`)]), {
  assert,
  logger,
  runUnitTests,
  runAllSuites,
  suiteTestNames,
});