Skip to content

Commit 1c36d10

Browse files
lukeedlukeed
committedJul 2, 2022
chore: tape -> uvu tests
·
v2.1.1v1.2.0
1 parent bc4f827 commit 1c36d10

File tree

4 files changed

+102
-120
lines changed

4 files changed

+102
-120
lines changed
 

‎.github/workflows/ci.yml

+4-1
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ jobs:
88
runs-on: ubuntu-latest
99
strategy:
1010
matrix:
11-
nodejs: [6, 8, 10, 12, 14, 16]
11+
nodejs: [8, 10, 12, 14, 16]
1212
steps:
1313
- uses: actions/checkout@v2
1414
- uses: actions/setup-node@v2
@@ -28,6 +28,9 @@ jobs:
2828
if: matrix.nodejs >= 16
2929
run: npm install -g nyc
3030

31+
- name: Build
32+
run: npm run build
33+
3134
- name: Test
3235
run: npm test
3336
if: matrix.nodejs < 16

‎package.json

+2-4
Original file line numberDiff line numberDiff line change
@@ -18,8 +18,7 @@
1818
},
1919
"scripts": {
2020
"build": "bundt",
21-
"pretest": "npm run build",
22-
"test": "tape -r esm test/*.js | tap-spec"
21+
"test": "uvu -r esm test"
2322
},
2423
"files": [
2524
"*.d.ts",
@@ -33,7 +32,6 @@
3332
"devDependencies": {
3433
"bundt": "1.0.1",
3534
"esm": "3.2.25",
36-
"tap-spec": "5.0.0",
37-
"tape": "4.9.1"
35+
"uvu": "0.5.4"
3836
}
3937
}

‎test/classnames.js

+39-51
Original file line numberDiff line numberDiff line change
@@ -2,84 +2,71 @@
22
* Ported from `classnames` for compatibility checks.
33
*/
44

5-
import test from 'tape';
6-
import fn from '../src';
5+
import { test } from 'uvu';
6+
import * as assert from 'uvu/assert';
7+
import clsx from '../src';
78

8-
test('(compat) keeps object keys with truthy values', t => {
9-
const out = fn({ a:true, b:false, c:0, d:null, e:undefined, f:1 });
10-
t.is(out, 'a f');
11-
t.end();
9+
test('(compat) keeps object keys with truthy values', () => {
10+
const out = clsx({ a:true, b:false, c:0, d:null, e:undefined, f:1 });
11+
assert.is(out, 'a f');
1212
});
1313

14-
test('(compat) joins arrays of class names and ignore falsy values', t => {
15-
const out = fn('a', 0, null, undefined, true, 1, 'b');
16-
t.is(out, 'a 1 b');
17-
t.end();
14+
test('(compat) joins arrays of class names and ignore falsy values', () => {
15+
const out = clsx('a', 0, null, undefined, true, 1, 'b');
16+
assert.is(out, 'a 1 b');
1817
});
1918

20-
test('(compat) supports heterogenous arguments', t => {
21-
t.is(fn({ a:true }, 'b', 0), 'a b');
22-
t.end();
19+
test('(compat) supports heterogenous arguments', () => {
20+
assert.is(clsx({ a:true }, 'b', 0), 'a b');
2321
});
2422

25-
test('(compat) should be trimmed', t => {
26-
t.is(fn('', 'b', {}, ''), 'b');
27-
t.end();
23+
test('(compat) should be trimmed', () => {
24+
assert.is(clsx('', 'b', {}, ''), 'b');
2825
});
2926

30-
test('(compat) returns an empty string for an empty configuration', t => {
31-
t.is(fn({}), '');
32-
t.end();
27+
test('(compat) returns an empty string for an empty configuration', () => {
28+
assert.is(clsx({}), '');
3329
});
3430

35-
test('(compat) supports an array of class names', t => {
36-
t.is(fn(['a', 'b']), 'a b');
37-
t.end();
31+
test('(compat) supports an array of class names', () => {
32+
assert.is(clsx(['a', 'b']), 'a b');
3833
});
3934

40-
test('(compat) joins array arguments with string arguments', t => {
41-
t.is(fn(['a', 'b'], 'c'), 'a b c');
42-
t.is(fn('c', ['a', 'b']), 'c a b');
43-
t.end();
35+
test('(compat) joins array arguments with string arguments', () => {
36+
assert.is(clsx(['a', 'b'], 'c'), 'a b c');
37+
assert.is(clsx('c', ['a', 'b']), 'c a b');
4438
});
4539

46-
test('(compat) handles multiple array arguments', t => {
47-
t.is(fn(['a', 'b'], ['c', 'd']), 'a b c d');
48-
t.end();
40+
test('(compat) handles multiple array arguments', () => {
41+
assert.is(clsx(['a', 'b'], ['c', 'd']), 'a b c d');
4942
});
5043

51-
test('(compat) handles arrays that include falsy and true values', t => {
52-
t.is(fn(['a', 0, null, undefined, false, true, 'b']), 'a b');
53-
t.end();
44+
test('(compat) handles arrays that include falsy and true values', () => {
45+
assert.is(clsx(['a', 0, null, undefined, false, true, 'b']), 'a b');
5446
});
5547

56-
test('(compat) handles arrays that include arrays', t => {
57-
t.is(fn(['a', ['b', 'c']]), 'a b c');
58-
t.end();
48+
test('(compat) handles arrays that include arrays', () => {
49+
assert.is(clsx(['a', ['b', 'c']]), 'a b c');
5950
});
6051

61-
test('(compat) handles arrays that include objects', t => {
62-
t.is(fn(['a', { b:true, c:false }]), 'a b');
63-
t.end();
52+
test('(compat) handles arrays that include objects', () => {
53+
assert.is(clsx(['a', { b:true, c:false }]), 'a b');
6454
});
6555

66-
test('(compat) handles deep array recursion', t => {
67-
t.is(fn(['a', ['b', ['c', { d:true }]]]), 'a b c d');
68-
t.end();
56+
test('(compat) handles deep array recursion', () => {
57+
assert.is(clsx(['a', ['b', ['c', { d:true }]]]), 'a b c d');
6958
});
7059

71-
test('(compat) handles arrays that are empty', t => {
72-
t.is(fn('a', []), 'a');
73-
t.end();
60+
test('(compat) handles arrays that are empty', () => {
61+
assert.is(clsx('a', []), 'a');
7462
});
7563

76-
test('(compat) handles nested arrays that have empty nested arrays', t => {
77-
t.is(fn('a', [[]]), 'a');
78-
t.end();
64+
test('(compat) handles nested arrays that have empty nested arrays', () => {
65+
assert.is(clsx('a', [[]]), 'a');
7966
});
8067

81-
test('(compat) handles all types of truthy and falsy property values as expected', t => {
82-
const out = fn({
68+
test('(compat) handles all types of truthy and falsy property values as expected', () => {
69+
const out = clsx({
8370
// falsy:
8471
null: null,
8572
emptyString: '',
@@ -100,6 +87,7 @@ test('(compat) handles all types of truthy and falsy property values as expected
10087
greaterZero: 1
10188
});
10289

103-
t.is(out, 'nonEmptyString whitespace function emptyObject nonEmptyObject emptyList nonEmptyList greaterZero');
104-
t.end();
90+
assert.is(out, 'nonEmptyString whitespace function emptyObject nonEmptyObject emptyList nonEmptyList greaterZero');
10591
});
92+
93+
test.run();

‎test/index.js

+57-64
Original file line numberDiff line numberDiff line change
@@ -1,88 +1,81 @@
1-
import test from 'tape';
1+
// @ts-check
2+
import { test } from 'uvu';
3+
import * as assert from 'uvu/assert';
24
import * as mod from '../src';
35

46
const fn = mod.default;
57

6-
test('exports', t => {
7-
t.is(typeof mod.default, 'function', 'exports default function');
8-
t.is(typeof mod.clsx, 'function', 'exports named function');
9-
t.ok(mod.default === mod.clsx, 'exports are equal');
10-
11-
t.is(typeof mod.default(), 'string', '~> returns string output');
12-
t.is(typeof mod.clsx(), 'string', '~> returns string output');
13-
14-
t.end();
8+
test('exports', () => {
9+
assert.type(mod.default, 'function', 'exports default function');
10+
assert.type(mod.clsx, 'function', 'exports named function');
11+
assert.is(mod.default, mod.clsx, 'exports are equal');
12+
13+
assert.type(mod.default(), 'string', '~> returns string output');
14+
assert.type(mod.clsx(), 'string', '~> returns string output');
1515
});
1616

17-
test('strings', t => {
18-
t.is(fn(''), '');
19-
t.is(fn('foo'), 'foo');
20-
t.is(fn(true && 'foo'), 'foo');
21-
t.is(fn(false && 'foo'), '');
22-
t.end();
17+
test('strings', () => {
18+
assert.is(fn(''), '');
19+
assert.is(fn('foo'), 'foo');
20+
assert.is(fn(true && 'foo'), 'foo');
21+
assert.is(fn(false && 'foo'), '');
2322
});
2423

25-
test('strings (variadic)', t => {
26-
t.is(fn(''), '');
27-
t.is(fn('foo', 'bar'), 'foo bar');
28-
t.is(fn(true && 'foo', false && 'bar', 'baz'), 'foo baz');
29-
t.is(fn(false && 'foo', 'bar', 'baz', ''), 'bar baz');
30-
t.end();
24+
test('strings (variadic)', () => {
25+
assert.is(fn(''), '');
26+
assert.is(fn('foo', 'bar'), 'foo bar');
27+
assert.is(fn(true && 'foo', false && 'bar', 'baz'), 'foo baz');
28+
assert.is(fn(false && 'foo', 'bar', 'baz', ''), 'bar baz');
3129
});
3230

33-
test('objects', t => {
34-
t.is(fn({}), '');
35-
t.is(fn({ foo:true }), 'foo');
36-
t.is(fn({ foo:true, bar:false }), 'foo');
37-
t.is(fn({ foo:'hiya', bar:1 }), 'foo bar');
38-
t.is(fn({ foo:1, bar:0, baz:1 }), 'foo baz');
39-
t.is(fn({ '-foo':1, '--bar':1 }), '-foo --bar');
40-
t.end();
31+
test('objects', () => {
32+
assert.is(fn({}), '');
33+
assert.is(fn({ foo:true }), 'foo');
34+
assert.is(fn({ foo:true, bar:false }), 'foo');
35+
assert.is(fn({ foo:'hiya', bar:1 }), 'foo bar');
36+
assert.is(fn({ foo:1, bar:0, baz:1 }), 'foo baz');
37+
assert.is(fn({ '-foo':1, '--bar':1 }), '-foo --bar');
4138
});
4239

43-
test('objects (variadic)', t => {
44-
t.is(fn({}, {}), '');
45-
t.is(fn({ foo:1 }, { bar:2 }), 'foo bar');
46-
t.is(fn({ foo:1 }, null, { baz:1, bat:0 }), 'foo baz');
47-
t.is(fn({ foo:1 }, {}, {}, { bar:'a' }, { baz:null, bat:Infinity }), 'foo bar bat');
48-
t.end();
40+
test('objects (variadic)', () => {
41+
assert.is(fn({}, {}), '');
42+
assert.is(fn({ foo:1 }, { bar:2 }), 'foo bar');
43+
assert.is(fn({ foo:1 }, null, { baz:1, bat:0 }), 'foo baz');
44+
assert.is(fn({ foo:1 }, {}, {}, { bar:'a' }, { baz:null, bat:Infinity }), 'foo bar bat');
4945
});
5046

51-
test('arrays', t => {
52-
t.is(fn([]), '');
53-
t.is(fn(['foo']), 'foo');
54-
t.is(fn(['foo', 'bar']), 'foo bar');
55-
t.is(fn(['foo', 0 && 'bar', 1 && 'baz']), 'foo baz');
56-
t.end();
47+
test('arrays', () => {
48+
assert.is(fn([]), '');
49+
assert.is(fn(['foo']), 'foo');
50+
assert.is(fn(['foo', 'bar']), 'foo bar');
51+
assert.is(fn(['foo', 0 && 'bar', 1 && 'baz']), 'foo baz');
5752
});
5853

59-
test('arrays (nested)', t => {
60-
t.is(fn([[[]]]), '');
61-
t.is(fn([[['foo']]]), 'foo');
62-
t.is(fn([true, [['foo']]]), 'foo');;
63-
t.is(fn(['foo', ['bar', ['', [['baz']]]]]), 'foo bar baz');
64-
t.end();
54+
test('arrays (nested)', () => {
55+
assert.is(fn([[[]]]), '');
56+
assert.is(fn([[['foo']]]), 'foo');
57+
assert.is(fn([true, [['foo']]]), 'foo');;
58+
assert.is(fn(['foo', ['bar', ['', [['baz']]]]]), 'foo bar baz');
6559
});
6660

67-
test('arrays (variadic)', t => {
68-
t.is(fn([], []), '');
69-
t.is(fn(['foo'], ['bar']), 'foo bar');
70-
t.is(fn(['foo'], null, ['baz', ''], true, '', []), 'foo baz');
71-
t.end();
61+
test('arrays (variadic)', () => {
62+
assert.is(fn([], []), '');
63+
assert.is(fn(['foo'], ['bar']), 'foo bar');
64+
assert.is(fn(['foo'], null, ['baz', ''], true, '', []), 'foo baz');
7265
});
7366

74-
test('arrays (no `push` escape)', t => {
75-
t.is(fn({ push:1 }), 'push');
76-
t.is(fn({ pop:true }), 'pop');
77-
t.is(fn({ push:true }), 'push');
78-
t.is(fn('hello', { world:1, push:true }), 'hello world push');
79-
t.end();
67+
test('arrays (no `push` escape)', () => {
68+
assert.is(fn({ push:1 }), 'push');
69+
assert.is(fn({ pop:true }), 'pop');
70+
assert.is(fn({ push:true }), 'push');
71+
assert.is(fn('hello', { world:1, push:true }), 'hello world push');
8072
});
8173

82-
test('functions', t => {
74+
test('functions', () => {
8375
const foo = () => {};
84-
t.is(fn(foo, 'hello'), 'hello');
85-
t.is(fn(foo, 'hello', fn), 'hello');
86-
t.is(fn(foo, 'hello', [[fn], 'world']), 'hello world');
87-
t.end();
76+
assert.is(fn(foo, 'hello'), 'hello');
77+
assert.is(fn(foo, 'hello', fn), 'hello');
78+
assert.is(fn(foo, 'hello', [[fn], 'world']), 'hello world');
8879
});
80+
81+
test.run();

0 commit comments

Comments
 (0)
Please sign in to comment.