How to use the tap.type function in tap

To help you get started, we’ve selected a few tap examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

schwarzkopfb / sse-broadcast / test / api.js View on Github

// make tests work on Node &lt;1
process.nextTick = require('process.nexttick')

var http     = require('http'),
    EE       = require('events').EventEmitter,
    AE       = require('assert').AssertionError,
    inherits = require('util').inherits,
    test     = require('tap'),
    sse      = require('../')

test.plan(33)

test.type(sse, 'function', 'main export should be a function')
test.type(sse.Broadcaster, 'function', 'constructor should be exposed')
test.equal(sse, sse.Broadcaster, 'constructor should be the main export')
test.type(sse.proto, 'function', 'prototype extender method should be exposed')
test.equal(sse.proto.length, 1, 'prototype extender method should accept one argument')
test.equal(
    sse.version, require(__dirname + '/../package.json').version,
    'package version should be exposed'
)

var server
test.doesNotThrow(
    function () {
         server = sse.Broadcaster()
    },
    '`new` keyword should not be necessary'
)

test.ok(server instanceof sse, '`new` keyword should not be necessary')
test.ok(server instanceof EE, 'server should be an EventEmitter instance')

schwarzkopfb / sse-broadcast / test / api.js View on Github

'use strict'

// make tests work on Node &lt;1
process.nextTick = require('process.nexttick')

var http     = require('http'),
    EE       = require('events').EventEmitter,
    AE       = require('assert').AssertionError,
    inherits = require('util').inherits,
    test     = require('tap'),
    sse      = require('../')

test.plan(33)

test.type(sse, 'function', 'main export should be a function')
test.type(sse.Broadcaster, 'function', 'constructor should be exposed')
test.equal(sse, sse.Broadcaster, 'constructor should be the main export')
test.type(sse.proto, 'function', 'prototype extender method should be exposed')
test.equal(sse.proto.length, 1, 'prototype extender method should accept one argument')
test.equal(
    sse.version, require(__dirname + '/../package.json').version,
    'package version should be exposed'
)

var server
test.doesNotThrow(
    function () {
         server = sse.Broadcaster()
    },
    '`new` keyword should not be necessary'
)

motdotla / dotenv / tests / test-parse.js View on Github

/* @flow */

const fs = require('fs')

const sinon = require('sinon')
const t = require('tap')

const dotenv = require('../lib/main')

const parsed = dotenv.parse(fs.readFileSync('tests/.env', { encoding: 'utf8' }))

t.plan(27)

t.type(parsed, Object, 'should return an object')

t.equal(parsed.BASIC, 'basic', 'sets basic environment variable')

t.equal(parsed.AFTER_LINE, 'after_line', 'reads after a skipped line')

t.equal(parsed.EMPTY, '', 'defaults empty values to empty string')

t.equal(parsed.SINGLE_QUOTES, 'single_quotes', 'escapes single quoted values')

t.equal(parsed.SINGLE_QUOTES_SPACED, '    single quotes    ', 'respects surrounding spaces in single quotes')

t.equal(parsed.DOUBLE_QUOTES, 'double_quotes', 'escapes double quoted values')

t.equal(parsed.DOUBLE_QUOTES_SPACED, '    double quotes    ', 'respects surrounding spaces in double quotes')

t.equal(parsed.EXPAND_NEWLINES, 'expand\nnew\nlines', 'expands newlines but only if double quoted')

skale-me / node-parquet / test / byte_array-write.js View on Github

#!/usr/bin/env node

var t = require('tap');
var parquet = require('..');

var schema = {ba: {type: 'byte_array'}};
var writer = new parquet.ParquetWriter(__dirname + '/test.parquet', schema, 'gzip');

t.type(writer, 'object');
writer.write([
  [Buffer.from('hello')],
  ['world'],
  ['00001a8a-e405-4337-a3ec-07dc7431a9c5'],
  [Buffer.from('00001a8a-e405-4337-a3ec-07dc7431a9c5')],
]);
writer.close();

schwarzkopfb / sse-broadcast / test / api.js View on Github

'`new` keyword should not be necessary'
)

test.ok(server instanceof sse, '`new` keyword should not be necessary')
test.ok(server instanceof EE, 'server should be an EventEmitter instance')
test.same(server._channels, {}, 'channel lookup object should be empty')
test.same(server.channels, [], 'channel name list should be returned')
test.type(server.subscribe, 'function', 'instance should have a `subscribe()` method')
test.equal(server.subscribe.length, 3, '`subscribe()` method should accept two arguments')
test.type(server.unsubscribe, 'function', 'instance should have a `unsubscribe()` method')
test.equal(server.unsubscribe.length, 2, '`unsubscribe()` method should accept two arguments')
test.type(server.publish, 'function', 'instance should have a `publish()` method')
test.equal(server.publish.length, 4, '`publish()` method should accept four arguments')
test.type(server.send, 'function', 'instance should have a `send()` method')
test.equal(server.send.length, 5, '`send()` method should accept five arguments')
test.type(server.sendEvent, 'function', 'instance should have a `sendEvent()` method')
test.equal(server.sendEvent.length, 5, '`sendEvent()` method should accept five arguments')
test.type(server.subscribers, 'function', 'instance should have a `subscribers()` method')
test.equal(server.subscribers.length, 1, '`subscribers()` method should accept four arguments')
test.type(server.subscriberCount, 'function', 'instance should have a `subscriberCount()` method')
test.equal(server.subscriberCount.length, 1, '`subscriberCount()` method should accept four arguments')
test.type(server.middleware, 'function', 'middleware factory method should be exposed')
test.equal(server.middleware.length, 1, 'middleware factory method should accept one argument')

function noop() {}
function FakeResponse() {
    this.socket = {
        setNoDelay: noop
    }
    this.writeHead = noop
    this.setHeader = noop
    this.write = function (data, encoding, callback) {

schwarzkopfb / sse-broadcast / test / api.js View on Github

var server
test.doesNotThrow(
    function () {
         server = sse.Broadcaster()
    },
    '`new` keyword should not be necessary'
)

test.ok(server instanceof sse, '`new` keyword should not be necessary')
test.ok(server instanceof EE, 'server should be an EventEmitter instance')
test.same(server._channels, {}, 'channel lookup object should be empty')
test.same(server.channels, [], 'channel name list should be returned')
test.type(server.subscribe, 'function', 'instance should have a `subscribe()` method')
test.equal(server.subscribe.length, 3, '`subscribe()` method should accept two arguments')
test.type(server.unsubscribe, 'function', 'instance should have a `unsubscribe()` method')
test.equal(server.unsubscribe.length, 2, '`unsubscribe()` method should accept two arguments')
test.type(server.publish, 'function', 'instance should have a `publish()` method')
test.equal(server.publish.length, 4, '`publish()` method should accept four arguments')
test.type(server.send, 'function', 'instance should have a `send()` method')
test.equal(server.send.length, 5, '`send()` method should accept five arguments')
test.type(server.sendEvent, 'function', 'instance should have a `sendEvent()` method')
test.equal(server.sendEvent.length, 5, '`sendEvent()` method should accept five arguments')
test.type(server.subscribers, 'function', 'instance should have a `subscribers()` method')
test.equal(server.subscribers.length, 1, '`subscribers()` method should accept four arguments')
test.type(server.subscriberCount, 'function', 'instance should have a `subscriberCount()` method')
test.equal(server.subscriberCount.length, 1, '`subscriberCount()` method should accept four arguments')
test.type(server.middleware, 'function', 'middleware factory method should be exposed')
test.equal(server.middleware.length, 1, 'middleware factory method should accept one argument')

function noop() {}
function FakeResponse() {

schwarzkopfb / sse-broadcast / test / api.js View on Github

test.ok(server instanceof sse, '`new` keyword should not be necessary')
test.ok(server instanceof EE, 'server should be an EventEmitter instance')
test.same(server._channels, {}, 'channel lookup object should be empty')
test.same(server.channels, [], 'channel name list should be returned')
test.type(server.subscribe, 'function', 'instance should have a `subscribe()` method')
test.equal(server.subscribe.length, 3, '`subscribe()` method should accept two arguments')
test.type(server.unsubscribe, 'function', 'instance should have a `unsubscribe()` method')
test.equal(server.unsubscribe.length, 2, '`unsubscribe()` method should accept two arguments')
test.type(server.publish, 'function', 'instance should have a `publish()` method')
test.equal(server.publish.length, 4, '`publish()` method should accept four arguments')
test.type(server.send, 'function', 'instance should have a `send()` method')
test.equal(server.send.length, 5, '`send()` method should accept five arguments')
test.type(server.sendEvent, 'function', 'instance should have a `sendEvent()` method')
test.equal(server.sendEvent.length, 5, '`sendEvent()` method should accept five arguments')
test.type(server.subscribers, 'function', 'instance should have a `subscribers()` method')
test.equal(server.subscribers.length, 1, '`subscribers()` method should accept four arguments')
test.type(server.subscriberCount, 'function', 'instance should have a `subscriberCount()` method')
test.equal(server.subscriberCount.length, 1, '`subscriberCount()` method should accept four arguments')
test.type(server.middleware, 'function', 'middleware factory method should be exposed')
test.equal(server.middleware.length, 1, 'middleware factory method should accept one argument')

function noop() {}
function FakeResponse() {
    this.socket = {
        setNoDelay: noop
    }
    this.writeHead = noop
    this.setHeader = noop
    this.write = function (data, encoding, callback) {
        callback()
    }

schwarzkopfb / sse-broadcast / test / api.js View on Github

test.same(server.channels, [], 'channel name list should be returned')
test.type(server.subscribe, 'function', 'instance should have a `subscribe()` method')
test.equal(server.subscribe.length, 3, '`subscribe()` method should accept two arguments')
test.type(server.unsubscribe, 'function', 'instance should have a `unsubscribe()` method')
test.equal(server.unsubscribe.length, 2, '`unsubscribe()` method should accept two arguments')
test.type(server.publish, 'function', 'instance should have a `publish()` method')
test.equal(server.publish.length, 4, '`publish()` method should accept four arguments')
test.type(server.send, 'function', 'instance should have a `send()` method')
test.equal(server.send.length, 5, '`send()` method should accept five arguments')
test.type(server.sendEvent, 'function', 'instance should have a `sendEvent()` method')
test.equal(server.sendEvent.length, 5, '`sendEvent()` method should accept five arguments')
test.type(server.subscribers, 'function', 'instance should have a `subscribers()` method')
test.equal(server.subscribers.length, 1, '`subscribers()` method should accept four arguments')
test.type(server.subscriberCount, 'function', 'instance should have a `subscriberCount()` method')
test.equal(server.subscriberCount.length, 1, '`subscriberCount()` method should accept four arguments')
test.type(server.middleware, 'function', 'middleware factory method should be exposed')
test.equal(server.middleware.length, 1, 'middleware factory method should accept one argument')

function noop() {}
function FakeResponse() {
    this.socket = {
        setNoDelay: noop
    }
    this.writeHead = noop
    this.setHeader = noop
    this.write = function (data, encoding, callback) {
        callback()
    }
}
inherits(FakeResponse, http.ServerResponse)

var res  = new FakeResponse,

auchenberg / volkswagen / test / tap.js View on Github

tap.doesNotThrow(function () {
  throw new Error('bang!')
})

tap.ok(true)
tap.notOk(false)
tap.error(undefined)
tap.equal('foo', 'foo')
tap.not('foo', 'bar')
tap.same({ foo: 1 }, { foo: 1 })
tap.notSame({ foo: 1 }, { bar: 1 })
tap.strictSame([42], [42])
tap.strictNotSame([null], [undefined])
tap.match({ foo: 'bar' }, { foo: /^bar$/ })
tap.notMatch({ foo: 'bar' }, { foo: /baz/ })
tap.type(new Date(), Date)
tap.throws(function () {
  throw new Error('bang!')
})
tap.doesNotThrow(function () {})

schwarzkopfb / sse-broadcast / test / api.js View on Github

test.doesNotThrow(
    function () {
         server = sse.Broadcaster()
    },
    '`new` keyword should not be necessary'
)

test.ok(server instanceof sse, '`new` keyword should not be necessary')
test.ok(server instanceof EE, 'server should be an EventEmitter instance')
test.same(server._channels, {}, 'channel lookup object should be empty')
test.same(server.channels, [], 'channel name list should be returned')
test.type(server.subscribe, 'function', 'instance should have a `subscribe()` method')
test.equal(server.subscribe.length, 3, '`subscribe()` method should accept two arguments')
test.type(server.unsubscribe, 'function', 'instance should have a `unsubscribe()` method')
test.equal(server.unsubscribe.length, 2, '`unsubscribe()` method should accept two arguments')
test.type(server.publish, 'function', 'instance should have a `publish()` method')
test.equal(server.publish.length, 4, '`publish()` method should accept four arguments')
test.type(server.send, 'function', 'instance should have a `send()` method')
test.equal(server.send.length, 5, '`send()` method should accept five arguments')
test.type(server.sendEvent, 'function', 'instance should have a `sendEvent()` method')
test.equal(server.sendEvent.length, 5, '`sendEvent()` method should accept five arguments')
test.type(server.subscribers, 'function', 'instance should have a `subscribers()` method')
test.equal(server.subscribers.length, 1, '`subscribers()` method should accept four arguments')
test.type(server.subscriberCount, 'function', 'instance should have a `subscriberCount()` method')
test.equal(server.subscriberCount.length, 1, '`subscriberCount()` method should accept four arguments')
test.type(server.middleware, 'function', 'middleware factory method should be exposed')
test.equal(server.middleware.length, 1, 'middleware factory method should accept one argument')

function noop() {}
function FakeResponse() {
    this.socket = {
        setNoDelay: noop

How to use the tap.type function in tap

To help you get started, we’ve selected a few tap examples, based on popular ways it is used in public projects.

tap

Package Health Score

Popular tap functions

Similar packages