npm package: @mazeltov/util
Description: Mazeltov utilities
Author: Jeff Straney
Latest version: 1.0.11

# 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

```js
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.

```js
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,
});
```