TypeScript blue-tape类代码示例

import * as d from 'doctrine';
import * as test from 'blue-tape';

test('parse no options', (t: test.Test) => {
  let res = d.parse('');
  t.plan(2);
  t.equal(res.description, '');
  t.equal(res.tags.length, 0);
});

test('parse empty options', (t: test.Test) => {
  let res = d.parse('', {});
  t.equal(res.description, '');
  t.equal(res.tags.length, 0);
  t.end();
});

test('parse all options', (t: test.Test) => {
  let res = d.parse('/* this is a test\n * @param {number} bees the number of bees\n */', {
    unwrap: true,
    tags: null,
    recoverable: true,
    sloppy: true,
    lineNumbers: true
  });
  t.plan(10);
  t.equal(res.description, 'this is a test');
  t.equal(res.tags.length, 1);
  t.equal(res.tags[0].title, 'param');
  t.equal(res.tags[0].name, 'bees');
  t.equal(res.tags[0].description, 'the number of bees');

import * as test from 'blue-tape';

import {Tracker} from 'are-we-there-yet';

let name = 'test';

test('initialization', (t) => {
  t.plan(1);
  let simple = new Tracker(name);
  t.is(simple.completed(), 0, 'Nothing todo is 0 completion');
});

import * as test from "blue-tape";
// import {inject} from "webpack-partial";

test("inject", (t) => {
  t.end();
});

import * as test from 'blue-tape';
import * as login from 'facebook-chat-api';

test('login', (t) => {
  t.plan(1);
  t.equal(typeof login, 'function');
});

import * as test from 'blue-tape';

import * as request from 'request';

test('request', (t) => {
  t.plan(1);
  t.equal(typeof request, 'function');
});

import * as test from 'blue-tape';
import * as redis from 'redis';

test('test', (t) => {
  t.plan(2);
  t.assert(typeof redis.debug_mode === 'boolean', 'debug_mode');
  t.assert(typeof redis.createClient === 'function', 'createClient');
});

import * as test from "blue-tape";
// import {partial} from "webpack-partial";

test("partial", (t) => {
  t.end();
});

import * as test from 'blue-tape';
import compose from '../src/compose';
import Site from '../src/site';
import ContentItemBuilder from '../src/content-item-builder';

test('compose', (t) => {

    t.test('identity function', async (st) => {
        const inSite = new Site([]);
        const outSite = await compose((site) => site, (site) => site)(inSite);
        st.equals(outSite, inSite, 'identity function composes correctly');
    });

    t.test('functions apply in order', async (st) => {
        const contentItem = new ContentItemBuilder(false, '').build();
        const site1 = new Site([]);
        const site2 = new Site([contentItem]);
        const outSite = await compose((site) => site1, (site) => site2)(site1);
        st.equals(outSite, site2, 'second function applies second');
    });

});

test('Site', (t) => {

    t.test('constructor', (st) => {
        const site = new Site([]);
        st.deepEquals(site.meta, {}, 'meta defaults to empty object');
        st.end();
    });

    t.test('#withMeta/#getMeta', (st) => {
        const key = 'key';
        const value = 'value';
        const site = new Site([]);
        const newSite = site.withMeta(key, value);
        st.equals(newSite.meta[key], value);
        st.assert(site.meta[key] === undefined);
        st.end();
    });

    t.test('#mapWithFilters', (st) => {
        {
            const site = new Site([ci(1), ci(2), ci(3), ci(4)])
                    .mapWithFilters([],
                        (x: ContentItem) => ci(parseInt(x.content) * 2));
            st.deepEquals(site.items, [ci(2), ci(4), ci(6), ci(8)],
                    'map applies to all items with no filters');
        }
        {
            const site = new Site([ci(1), ci(2), ci(3), ci(4)])
                    .mapWithFilters([
                        (x: ContentItem) => intContent(x) < 2,
                        (x: ContentItem) => intContent(x) > 3
                    ], (x: ContentItem) => ci(intContent(x) * 2));
            st.deepEquals(site.items, [ci(1), ci(4), ci(6), ci(4)],
                    'map only applies to unfiltered items');
        }
        st.end();
    });

    t.test('#forEachWithFilters', (st) => {
        const ci3 = cid(3, [ci(1), ci(2)]);
        const ci1 = ci3.children.getNthContentItem(0);
        const ci2 = ci3.children.getNthContentItem(1);
        const ci4 = ci(4);
        {
            const result: ContentItem[] = [];
            new Site([ci3, ci4]).forEachWithFilters([], (x: ContentItem) => {
                result.push(x);
            });
            st.deepEquals(result, [ci1, ci2, ci3, ci4],
                    'for each applies to all items with no filters');
        }
        {
            const result: ContentItem[] = [];
            new Site([ci3, ci4]).forEachWithFilters(
                [(x: ContentItem) => intContent(x) < 2, (x: ContentItem) => intContent(x) > 3],
                (x: ContentItem) => {
                    result.push(x);
                });
            st.deepEquals(result, [ci2, ci3],
                    'for each applies to unfiltered items with filters');
        }
        st.end();
    });

    t.test('#forEachWithFiltersTopLevel', (st) => {
        {
            const input = [ci(1), ci(2), cid(3, [ci(4)])];
            const result: ContentItem[] = [];
            new Site(input).forEachWithFiltersTopLevel([], (x: ContentItem) => {
                result.push(x);
            });
            st.deepEquals(result, input,
                    'for each applies to all items with no filters');
        }
        {
            const result: ContentItem[] = [];
            new Site([ci(1), ci(2), ci(3), ci(4)]).forEachWithFiltersTopLevel(
                [(x) => intContent(x) < 2, (x) => intContent(x) > 3], (x: ContentItem) => {
                    result.push(x);
                });
            st.deepEquals(result, [ci(2), ci(3)],
                    'for each applies to unfiltered items with filters');
        }
        st.end();
    });

    t.test('#writeToPath', async (st) => {
        const site = new Site([ci(1), cid(4, [ci(2), ci(3)])]);
        await site.writeToPath('/test');
        st.assert(writeFileStub.calledWith('/test/1', '1'), 'file 1');
        st.assert(writeFileStub.calledWith('/test/4/2', '2'), 'file 2');
        st.assert(writeFileStub.calledWith('/test/4/3', '3'), 'file 3');
    });

    t.test('readSiteFromPath', async (st) => {
        const path = '/a';
        const files = ['1'];
        readdirStub.withArgs(path).returns(Promise.resolve(files));
        lstatStub.returns(Promise.resolve({
            isDirectory() {
//.........这里部分代码省略.........

  '\u001b[0m'
];

let result = [];
let stream: any = new Stream();
stream.write = function (message) {
  result.push(message);
};

stream.writable = true;
stream.isTTY = true;
stream.end = function () {};

npmlog.stream = stream;

npmlog.heading = 'npm';

test('request', (t) => {
  t.plan(1);
  npmlog.level = 'silly';
  npmlog.silly('silly prefix', 'x = %j', {foo:{bar:'baz'}});
  npmlog.verbose('verbose prefix', 'x = %j', {foo:{bar:'baz'}});
  npmlog.info('info prefix', 'x = %j', {foo:{bar:'baz'}});
  npmlog.http('http prefix', 'x = %j', {foo:{bar:'baz'}});
  npmlog.warn('warn prefix', 'x = %j', {foo:{bar:'baz'}});
  npmlog.error('error prefix', 'x = %j', {foo:{bar:'baz'}});
  npmlog.silent('silent prefix', 'x = %j', {foo:{bar:'baz'}});

  t.deepEqual(result.join('').trim(), resultExpect.join('').trim(), 'result');
});