@ryanatkn/gro 0.129.7 → 0.129.9

package/src/lib/run_task.test.ts

@@ -1,86 +0,0 @@
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-import {Timings} from '@ryanatkn/belt/timings.js';
-
-import {run_task} from './run_task.js';
-import {load_config} from './config.js';
-
-test('passes args and returns output', async () => {
-	const args = {a: 1, _: []};
-	const result = await run_task(
-		{
-			name: 'testTask',
-			id: 'foo/testTask',
-			mod: {
-				task: {
-					run: ({args}) => Promise.resolve(args),
-				},
-			},
-		},
-		args,
-		() => Promise.resolve(),
-		await load_config(),
-		new Timings(),
-	);
-	assert.ok(result.ok);
-	assert.is(result.output, args);
-});
-
-test('invokes a sub task', async () => {
-	const args = {a: 1, _: []};
-	let invoked_task_name;
-	let invoked_args;
-	const result = await run_task(
-		{
-			name: 'testTask',
-			id: 'foo/testTask',
-			mod: {
-				task: {
-					run: async ({args, invoke_task}) => {
-						await invoke_task('bar/testTask', args);
-						return args;
-					},
-				},
-			},
-		},
-		args,
-		(invoking_task_name, invoking_args) => {
-			invoked_task_name = invoking_task_name;
-			invoked_args = invoking_args;
-			return Promise.resolve();
-		},
-		await load_config(),
-		new Timings(),
-	);
-	assert.ok(result.ok);
-	assert.is(invoked_task_name, 'bar/testTask');
-	assert.is(invoked_args, args);
-	assert.is(result.output, args);
-});
-
-test('failing task', async () => {
-	let err;
-	const result = await run_task(
-		{
-			name: 'testTask',
-			id: 'foo/testTask',
-			mod: {
-				task: {
-					run: () => {
-						err = Error();
-						throw err;
-					},
-				},
-			},
-		},
-		{_: []},
-		async () => {}, // eslint-disable-line @typescript-eslint/no-empty-function
-		await load_config(),
-		new Timings(),
-	);
-	assert.ok(!result.ok);
-	assert.ok(result.reason);
-	assert.is(result.error, err);
-});
-
-test.run();

package/src/lib/search_fs.test.ts

@@ -1,56 +0,0 @@
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-import {resolve} from 'node:path';
-
-import {search_fs} from './search_fs.js';
-
-test('search_fs basic behavior', () => {
-	const ignored_path = 'test1.foo.ts';
-	let has_ignored_path = false;
-	const result = search_fs('./src/fixtures', {
-		filter: (path) => {
-			if (!has_ignored_path) has_ignored_path = path.endsWith(ignored_path);
-			return !path.endsWith(ignored_path);
-		},
-		sort: (a, b) => a.path.localeCompare(b.path) * -1,
-	});
-	assert.ok(has_ignored_path); // makes sure the test isn't wrong
-	const expected_files = [
-		'test2.foo.ts',
-		'test_ts.ts',
-		'test_task_module.task_fixture.ts',
-		'test_js.js',
-		'test_invalid_task_module.ts',
-		'test_file.other.ext',
-		'test_failing_task_module.ts',
-		'some_test_side_effect.ts',
-		'some_test_json.json',
-		'some_test_exports3.ts',
-		'some_test_exports2.ts',
-		'some_test_exports.ts',
-		'modules/some_test_ts.ts',
-		'modules/Some_Test_Svelte.svelte',
-		'modules/some_test_svelte_ts.svelte.ts',
-		'modules/some_test_svelte_js.svelte.js',
-		'modules/some_test_server.ts',
-		'modules/some_test_json.json',
-		'modules/some_test_js.js',
-		'modules/some_test_css.css',
-		'changelog_example.md',
-		'changelog_cache.json',
-		'baz2/test2.baz.ts',
-		'baz1/test1.baz.ts',
-		'bar2/test2.bar.ts',
-		'bar1/test1.bar.ts',
-	];
-	assert.equal(
-		result.map((f) => f.path),
-		expected_files,
-	);
-	assert.equal(
-		result.map((f) => f.id),
-		expected_files.map((f) => resolve(`src/fixtures/${f}`)),
-	);
-});
-
-test.run();

package/src/lib/src_json.test.ts

@@ -1,49 +0,0 @@
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-
-import {to_src_modules} from './src_json.js';
-import {to_package_exports} from './package_json.js';
-import {paths} from './paths.js';
-
-test('to_package_modules', () => {
-	assert.equal(
-		to_src_modules(
-			to_package_exports([
-				'fixtures/modules/some_test_css.css',
-				'fixtures/modules/Some_Test_Svelte.svelte',
-				'fixtures/modules/some_test_ts.ts',
-				'fixtures/modules/some_test_json.json',
-			]),
-			undefined,
-			paths.source,
-		),
-		{
-			'./package.json': {path: 'package.json', declarations: []},
-			'./fixtures/modules/some_test_css.css': {
-				path: 'fixtures/modules/some_test_css.css',
-				declarations: [],
-			},
-			'./fixtures/modules/some_test_json.json': {
-				path: 'fixtures/modules/some_test_json.json',
-				declarations: [],
-			},
-			'./fixtures/modules/Some_Test_Svelte.svelte': {
-				path: 'fixtures/modules/Some_Test_Svelte.svelte',
-				declarations: [],
-			},
-			'./fixtures/modules/some_test_ts.js': {
-				path: 'fixtures/modules/some_test_ts.ts',
-				declarations: [
-					{name: 'a', kind: 'variable'},
-					{name: 'some_test_ts', kind: 'variable'},
-					{name: 'some_test_fn', kind: 'function'},
-					{name: 'Some_Test_Type', kind: 'type'},
-					{name: 'Some_Test_Interface', kind: 'type'},
-					{name: 'Some_Test_Class', kind: 'class'},
-				],
-			},
-		},
-	);
-});
-
-test.run();

package/src/lib/task.test.ts

@@ -1,84 +0,0 @@
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-import {resolve} from 'node:path';
-
-import {is_task_path, to_task_name, validate_task_module, find_tasks, load_tasks} from './task.js';
-import * as actual_test_task_module from './test.task.js';
-import {create_empty_config} from './config.js';
-
-test('is_task_path basic behavior', () => {
-	assert.ok(is_task_path('foo.task.ts'));
-	assert.ok(is_task_path('foo.task.js'));
-	assert.ok(!is_task_path('foo.ts'));
-	assert.ok(is_task_path('bar/baz/foo.task.ts'));
-	assert.ok(!is_task_path('bar/baz/foo.ts'));
-});
-
-test('to_task_name basic behavior', () => {
-	assert.is(to_task_name('foo.task.ts', process.cwd(), '', ''), 'foo');
-	assert.is(to_task_name('bar/baz/foo.task.ts', process.cwd(), '', ''), 'bar/baz/foo');
-	assert.is(to_task_name('a/b/c/foo.task.ts', 'a/b/c', '', ''), 'foo');
-	assert.is(to_task_name('a/b/c/foo.task.ts', 'a', '', ''), 'b/c/foo');
-	assert.is(to_task_name('a/b/c/foo.task.ts', 'a/b', '', ''), 'c/foo');
-	assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b/d'), '../c/foo');
-	assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b'), 'c/foo');
-	assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b/c'), 'foo');
-	assert.is(to_task_name('/a/b/d/foo.task.js', '/a/b/d', '/a/b/d/foo', '/a/c'), '../b/d/foo');
-	assert.is(
-		to_task_name(
-			'/a/node_modules/b/c/foo.task.js',
-			'/a/node_modules/b/c',
-			'/a/node_modules/b/c/foo',
-			'/a',
-		),
-		'foo',
-	);
-	assert.is(
-		to_task_name(
-			'/a/node_modules/b/c/foo.task.js',
-			'/a/node_modules/b/c/', // compared to the above, adds a trailing slash here
-			'/a/node_modules/b/c/foo',
-			'/a',
-		),
-		'foo',
-	);
-	assert.is(
-		to_task_name(
-			'/a/node_modules/b/c/foo.task.js',
-			'/a/node_modules/b/c',
-			'/a/node_modules/b/c/foo',
-			'/a/', // compared to the above, adds a trailing slash here
-		),
-		'foo',
-	);
-	assert.is(
-		to_task_name(resolve('a/b'), resolve('b'), '', ''),
-		resolve('a/b'),
-		'falls back to the id when unresolved',
-	);
-});
-
-// TODO if we import directly, svelte-package generates types in `src/fixtures`
-const test_task_module = await import('../fixtures/' + 'test_task_module.task_fixture'); // eslint-disable-line no-useless-concat
-const test_invalid_task_module = await import('../fixtures/' + 'test_invalid_task_module.js'); // eslint-disable-line no-useless-concat
-
-test('validate_task_module basic behavior', () => {
-	assert.ok(validate_task_module(test_task_module));
-	assert.ok(!validate_task_module(test_invalid_task_module));
-	assert.ok(!validate_task_module({task: {run: {}}}));
-});
-
-test('load_tasks basic behavior', async () => {
-	const found = find_tasks(
-		[resolve('src/lib/test'), resolve('src/lib/test.task.ts')],
-		[resolve('src/lib')],
-		create_empty_config(),
-	);
-	assert.ok(found.ok);
-	const result = await load_tasks(found.value);
-	assert.ok(result.ok);
-	assert.is(result.value.modules.length, 1);
-	assert.is(result.value.modules[0].mod, actual_test_task_module);
-});
-
-test.run();

package/src/lib/throttle.test.ts

@@ -1,52 +0,0 @@
-import {wait} from '@ryanatkn/belt/async.js';
-import {test} from 'uvu';
-import * as assert from 'uvu/assert';
-
-import {throttle} from './throttle.js';
-
-test('throttles calls to a function', async () => {
-	const results: string[] = [];
-	const fn = throttle(async (name: string) => {
-		results.push(name + '_run');
-		await wait();
-		results.push(name + '_done');
-	});
-	const promise_a = fn('a');
-	const promise_b = fn('b'); // discarded
-	const promise_c = fn('c'); // discarded
-	const promise_d = fn('d');
-	assert.ok(promise_a !== promise_b);
-	assert.is(promise_b, promise_c);
-	assert.is(promise_b, promise_d);
-	assert.equal(results, ['a_run']);
-	await promise_a;
-	assert.equal(results, ['a_run', 'a_done']);
-	await promise_b;
-	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done']);
-	const promise_e = fn('e'); // discarded
-	const promise_f = fn('f');
-	assert.ok(promise_d !== promise_e);
-	assert.is(promise_e, promise_f);
-	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done']); // delayed
-	await wait();
-	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run']);
-	await promise_e;
-	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done']);
-	const promise_g = fn('g');
-	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done']); // delayed
-	await wait();
-	assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done', 'g_run']);
-	await promise_g;
-	assert.equal(results, [
-		'a_run',
-		'a_done',
-		'd_run',
-		'd_done',
-		'f_run',
-		'f_done',
-		'g_run',
-		'g_done',
-	]);
-});
-
-test.run();