tunnckoCore/mukla

View on GitHub
.verb.md

Summary

Maintainability
Test Coverage
# {%= name %} {%= badge('npm') %} [![mit license][license-img]][license-url] {%= badge('downloads') %} [![npm total downloads][downloads-img]][downloads-url]

> {%= description %}

[![code climate][codeclimate-img]][codeclimate-url] 
[![code style][standard-img]][standard-url] 
[![linux build][travis-img]][travis-url] 
[![windows build][appveyor-img]][appveyor-url] 
[![code coverage][coverage-img]][coverage-url] 
[![dependency status][david-img]][david-url]
[![paypal donate][paypalme-img]][paypalme-url] 

## Hightlights
- Extremely lightweight and fast
- Small to download and install
- No implicit globals,
- No CLI, use plain `node test.js`
- Powered by [always-done][]
- And so supports async/await, promises, observables streams and callbacks
- Enforces writing atomic tests
- Simple test syntax - just a single `test()` function
- Works seamlessly with [istanbul][] for code coverage
- Stops after first failing test (also known as _"fail fast"_ or _"bail"_)
- Built-in [core-assert][] assertion library
- Targets and works at node.js v0.10 and above
- No need for build/transpilation/compilation step
- Backward-compatible with [assertit][] and so [testit][]
- Easy to porting of [mocha][]-style tests
- Clean stack traces by default, using [stacktrace-metadata][]
- Custom reporters, one built-in

## Table of Contents
<!-- toc -->

## Install
Install with [npm](https://www.npmjs.com/)

```
$ npm install {%= name %} --save
```

or install using [yarn](https://yarnpkg.com)

```
$ yarn add {%= name %}
```


## Usage
> For more use-cases see the [tests](./test.js)

### Write tests in ES2015

```js
import fs from 'fs'
import test from 'mukla'

test(done => {
  test.deepEqual([1, 2], [1, 2]) // passing
  done()
})

// or without `done`, returning Promise
// stream, observerable and so on
test(() => {
  return fs.createReadStream('not exist') // failing test
})
```

### The old way

```js
var fs = require('fs')
var test = require('{%= name %}')

test(function (done) {
  test.deepEqual([1, 2], [1, 2]) // passing
  done()
})

// or without `done`, returning Promise
// stream, observerable and so on
test(function () {
  return fs.createReadStream('not exists') // failing
})
```

## API
{%= apidocs('index.js') %}

## Supports
> Handles completion and errors of async/await, synchronous and asynchronous (callback) functions, also tests that returns streams, promises, child process and observables.

### Async/await function support

```js
var test = require('mukla')

test('passing modern test', async function () {
  return await Promise.resolve('foobar')
})
```

**[back to top](#readme)**

### Promise support

#### Returning a resolved Promise

```js
var test = require('mukla')

test('passing promise test', function () {
  return Promise.resolve(12345)
})
```

#### Returning a rejected Promise

```js
var test = require('mukla')

test('failing test with promise', function () {
  return Promise.reject(new Error('foo bar'))
})
```

**[back to top](#readme)**

### Observable support
> Using `.subscribe` method of the observable

#### Empty observable
```js
var test = require('mukla')
var Observable = require('rx').Observable

test('passing test with empty observable', function () {
  return Observable.empty()
})
```

#### Successful test wtih observable

```js
var test = require('mukla')
var Observable = require('rx').Observable

alwaysDone(function () {
  return Observable.return([1, 2, 3])
})
```

#### Failing observable

```js
var test = require('mukla')
var Observable = require('rx').Observable

test(function () {
  return Observable.throw(new Error('observable error'))
})
```

**[back to top](#readme)**

### Regular callbacks support

```js
var test = require('mukla')
var fs = require('fs')

test('some callback test', function (done) {
  fs.readFile('./package.json', 'utf8', function (err, res) {
    test.strictEqual(err, null)
    test.strictEqual(typeof res, 'string')
    test.strictEqual(res.length > 0, true)
    done()
  })
})
```

**[back to top](#readme)**

### Synchronous functions support

#### Passing sync test

```js
var fs = require('fs')
var test = require('mukla')

test(function () {
  var res = fs.readFileSync('./package.json')
  test.strictEqual(typeof res, 'string')
})
```

#### Failing test with title

```js
var test = require('mukla')

test('some failing test', function () {
  JSON.parse('{Sjkfsf:"dfgfg')
})
```

**[back to top](#readme)**

### Support functions that returns streams
> Handles completion of tests using [on-stream-end][] and [stream-exhaust][], behind the scenes, using [always-done][]

#### Passing test with unpiped streams

```js
var fs = require('fs')
var test = require('mukla')

test(function () {
  return fs.createReadStream('./package.json')
})
```

#### Failing test unpiped streams

```js
var fs = require('fs')
var test = require('mukla')

test('failing stream test', function () {
  return fs.createReadStream('foo bar')
})
```

#### Failing test with piped streams

```js
var fs = require('fs')
var test = require('mukla')
var through2 = require('through2')

test(function () {
  var read = fs.createReadStream('foo bar')
  return read.pipe(through2())
})
```

**[back to top](#readme)**

### Support functions that returns Child Process
> Basically, they are streams, so completion is handled using [on-stream-end][] which is drop-in replacement for [end-of-stream][]

#### Successful exec

```js
var test = require('mukla')
var cp = require('child_process')
var isChildProcess = require('is-child-process')

test('returning child processes', function () {
  var proc = cp.exec('echo hello world')
  test.strictEqual(isChildProcess(proc), true)
  return proc
})
```

#### Failing exec

```js
var test = require('mukla')
var cp = require('child_process')

test('should be failing exec test', function () {
  return cp.exec('foo-bar-baz sasa')
})
```

#### Failing spawn

```js
var test = require('mukla')
var cp = require('child_process')

test('failing child process spawn test', function () {
  return cp.spawn('foo-bar-baz', ['hello world'])
})
```

**[back to top](#readme)**

### Handles any errors

#### uncaught exceptions

```js
var test = require('mukla')

test('should be failing test with ReferenceError', function () {
  foo // ReferenceError
  return 55
})
```

#### if test throws

```js
var test = require('mukla')

test('failing test with SyntaxError', function () {
  JSON.parse('{"foo":')
})
```

**[back to top](#readme)**

{% if (verb.related && verb.related.list && verb.related.list.length) { %}
## Related
{%= related(verb.related.list, {words: 20}) %}
{% } %}

## Contributing
Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/{%= repository %}/issues/new).  
Please read the [contributing guidelines](CONTRIBUTING.md) for advice on opening issues, pull requests, and coding standards.  
If you need some help and can spent some cash, feel free to [contact me at CodeMentor.io](https://www.codementor.io/tunnckocore?utm_source=github&utm_medium=button&utm_term=tunnckocore&utm_campaign=github) too.

**In short:** If you want to contribute to that project, please follow these things

1. Please DO NOT edit [README.md](README.md), [CHANGELOG.md](CHANGELOG.md) and [.verb.md](.verb.md) files. See ["Building docs"](#building-docs) section.
2. Ensure anything is okey by installing the dependencies and run the tests. See ["Running tests"](#running-tests) section.
3. Always use `npm run commit` to commit changes instead of `git commit`, because it is interactive and user-friendly. It uses [commitizen][] behind the scenes, which follows Conventional Changelog idealogy.
4. Do NOT bump the version in package.json. For that we use `npm run release`, which is [standard-version][] and follows Conventional Changelog idealogy.

Thanks a lot! :)

## Building docs
Documentation and that readme is generated using [verb-generate-readme][], which is a [verb][] generator, so you need to install both of them and then run `verb` command like that

```
$ npm install verbose/verb#dev verb-generate-readme --global && verb
```

_Please don't edit the README directly. Any changes to the readme must be made in [.verb.md](.verb.md)._

## Running tests
Clone repository and run the following in that cloned directory

```
$ npm install && npm test
```

## Author
{%= includeEither('authors', 'author') %}
+ [codementor/tunnckoCore](https://codementor.io/tunnckoCore)

## License
{%= copyright({ start: 2015, linkify: true, prefix: 'Copyright', symbol: '©' }) %} {%= licenseStatement %}

***

{%= include('footer') %}  
_Project scaffolded using [charlike][] cli._

{%= reflinks(verb.reflinks) %}

[license-url]: https://www.npmjs.com/package/{%= name %}
[license-img]: https://img.shields.io/npm/l/{%= name %}.svg

[downloads-url]: https://www.npmjs.com/package/{%= name %}
[downloads-img]: https://img.shields.io/npm/dt/{%= name %}.svg

[codeclimate-url]: https://codeclimate.com/github/{%= repository %}
[codeclimate-img]: https://img.shields.io/codeclimate/github/{%= repository %}.svg

[travis-url]: https://travis-ci.org/{%= repository %}
[travis-img]: https://img.shields.io/travis/{%= repository %}/master.svg?label=linux

[appveyor-url]: https://ci.appveyor.com/project/tunnckoCore/{%= name %}
[appveyor-img]: https://img.shields.io/appveyor/ci/tunnckoCore/{%= name %}/master.svg?label=windows

[coverage-url]: https://codecov.io/gh/{%= repository %}
[coverage-img]: https://img.shields.io/codecov/c/github/{%= repository %}/master.svg

[david-url]: https://david-dm.org/{%= repository %}
[david-img]: https://img.shields.io/david/{%= repository %}.svg

[standard-url]: https://github.com/feross/standard
[standard-img]: https://img.shields.io/badge/code%20style-standard-brightgreen.svg

[paypalme-url]: https://www.paypal.me/tunnckoCore
[paypalme-img]: https://img.shields.io/badge/paypal-donate-brightgreen.svg