@showrun/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Emrah Yalaz, Anil Seyrek, Mahmut Karaca
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/__tests__/dsl-validation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dsl-validation.test.d.ts.map

package/dist/__tests__/dsl-validation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsl-validation.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/dsl-validation.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/dsl-validation.test.js

@@ -0,0 +1,203 @@
+import { describe, it, expect } from 'vitest';
+import { validateFlow, ValidationError } from '../dsl/validation.js';
+describe('validateFlow — collect-all errors', () => {
+    it('collects multiple errors from a single step', () => {
+        const errors = [];
+        // Step with no id, no type, no params
+        validateFlow([{}], errors);
+        expect(errors.length).toBeGreaterThanOrEqual(3);
+        expect(errors.some((e) => e.includes('must have a non-empty string "id"'))).toBe(true);
+        expect(errors.some((e) => e.includes('must have a non-empty string "type"'))).toBe(true);
+        expect(errors.some((e) => e.includes('must have a "params" object'))).toBe(true);
+    });
+    it('collects errors from multiple bad steps', () => {
+        const errors = [];
+        validateFlow([
+            { id: 'nav_1', type: 'navigate', params: {} }, // missing url
+            { id: 'click_1', type: 'click', params: { first: 'yes' } }, // missing target + bad first
+        ], errors);
+        expect(errors.length).toBeGreaterThanOrEqual(3);
+        // Errors from step 0
+        expect(errors.some((e) => e.includes('Step 0') && e.includes('Navigate'))).toBe(true);
+        // Errors from step 1
+        expect(errors.some((e) => e.includes('Step 1') && e.includes('Click step must have either'))).toBe(true);
+        expect(errors.some((e) => e.includes('Step 1') && e.includes('"first" must be a boolean'))).toBe(true);
+    });
+    it('reports nested target errors alongside param errors', () => {
+        const errors = [];
+        validateFlow([
+            {
+                id: 'click_bad',
+                type: 'click',
+                params: {
+                    target: { kind: 'role', role: 'INVALID' }, // bad role
+                    first: 'not-bool', // bad type
+                },
+            },
+        ], errors);
+        expect(errors.length).toBeGreaterThanOrEqual(2);
+        expect(errors.some((e) => e.includes('Role target must have a valid role'))).toBe(true);
+        expect(errors.some((e) => e.includes('"first" must be a boolean'))).toBe(true);
+    });
+    it('reports duplicate ID alongside field-level errors', () => {
+        const errors = [];
+        validateFlow([
+            { id: 'dup', type: 'navigate', params: { url: 'https://example.com' } },
+            { id: 'dup', type: 'click', params: {} }, // duplicate ID + missing target
+        ], errors);
+        expect(errors.some((e) => e.includes('Duplicate step ID'))).toBe(true);
+        expect(errors.some((e) => e.includes('Click step must have either'))).toBe(true);
+    });
+    it('backwards compat: throws on first error when collectedErrors is omitted', () => {
+        expect(() => validateFlow([
+            { id: 'nav_1', type: 'navigate', params: {} }, // missing url
+            { id: 'click_1', type: 'click', params: {} }, // missing target
+        ])).toThrow(ValidationError);
+        // Should throw only one error (the first)
+        try {
+            validateFlow([
+                { id: 'nav_1', type: 'navigate', params: {} },
+                { id: 'click_1', type: 'click', params: {} },
+            ]);
+        }
+        catch (e) {
+            expect(e).toBeInstanceOf(ValidationError);
+            // Message should reference step 0 only
+            expect(e.message).toContain('Step 0');
+        }
+    });
+    it('collects no errors for a valid flow', () => {
+        const errors = [];
+        validateFlow([
+            { id: 'nav_1', type: 'navigate', params: { url: 'https://example.com' } },
+            { id: 'click_1', type: 'click', params: { selector: '#btn' } },
+        ], errors);
+        expect(errors).toEqual([]);
+    });
+    it('error prefix includes step index, id, and type', () => {
+        const errors = [];
+        validateFlow([{ id: 'my_step', type: 'navigate', params: {} }], errors);
+        expect(errors.length).toBe(1);
+        expect(errors[0]).toMatch(/^Step 0 \(id="my_step", type="navigate"\):/);
+    });
+    it('uses "?" for unknown id and type', () => {
+        const errors = [];
+        validateFlow([{ params: { url: 'https://example.com' } }], errors);
+        expect(errors.some((e) => e.includes('id="?"'))).toBe(true);
+        expect(errors.some((e) => e.includes('type="?"'))).toBe(true);
+    });
+    it('handles non-array input with collectedErrors', () => {
+        const errors = [];
+        validateFlow('not-an-array', errors);
+        expect(errors).toEqual(['Flow must be an array of steps']);
+    });
+    it('handles non-array input without collectedErrors (throws)', () => {
+        expect(() => validateFlow('not-an-array')).toThrow('Flow must be an array of steps');
+    });
+    it('handles step that is not an object', () => {
+        const errors = [];
+        validateFlow([null, 'string-step', 42], errors);
+        expect(errors.length).toBe(3);
+        expect(errors[0]).toContain('Step 0');
+        expect(errors[1]).toContain('Step 1');
+        expect(errors[2]).toContain('Step 2');
+    });
+});
+describe('validateFlow — unknown params rejection', () => {
+    it('rejects unknown params like "extract" and "expression" on extract_text', () => {
+        const errors = [];
+        validateFlow([
+            {
+                id: 'bad_extract',
+                type: 'extract_text',
+                params: {
+                    selector: '.price',
+                    out: 'price',
+                    extract: 'eval',
+                    expression: 'parseFloat(text)',
+                },
+            },
+        ], errors);
+        expect(errors.length).toBe(1);
+        expect(errors[0]).toContain('Unknown param(s) "extract", "expression"');
+        expect(errors[0]).toContain('"extract_text" step');
+        expect(errors[0]).toContain('Allowed params:');
+    });
+    it('provides eval hint when unknown param name looks eval-like', () => {
+        const errors = [];
+        validateFlow([
+            {
+                id: 'eval_step',
+                type: 'extract_text',
+                params: {
+                    selector: '.data',
+                    out: 'result',
+                    eval: 'some expression',
+                },
+            },
+        ], errors);
+        expect(errors.length).toBe(1);
+        expect(errors[0]).toContain('network_extract step with a JMESPath');
+    });
+    it('does not provide eval hint for non-eval-like unknown params', () => {
+        const errors = [];
+        validateFlow([
+            {
+                id: 'typo_step',
+                type: 'click',
+                params: {
+                    selector: '#btn',
+                    frist: true, // typo of "first"
+                },
+            },
+        ], errors);
+        expect(errors.length).toBe(1);
+        expect(errors[0]).toContain('Unknown param(s) "frist"');
+        expect(errors[0]).not.toContain('network_extract');
+    });
+    it('detects eval() in string param values', () => {
+        const errors = [];
+        validateFlow([
+            {
+                id: 'eval_value',
+                type: 'fill',
+                params: {
+                    selector: '#input',
+                    value: 'eval(document.cookie)',
+                },
+            },
+        ], errors);
+        expect(errors.some((e) => e.includes('contains eval()'))).toBe(true);
+        expect(errors.some((e) => e.includes('network_extract'))).toBe(true);
+    });
+    it('allows valid params without errors', () => {
+        const errors = [];
+        validateFlow([
+            {
+                id: 'valid_extract',
+                type: 'extract_text',
+                params: {
+                    selector: '.price',
+                    out: 'price',
+                    first: true,
+                    trim: true,
+                    default: 'N/A',
+                },
+            },
+        ], errors);
+        expect(errors).toEqual([]);
+    });
+    it('does not reject unknown params for unknown step types', () => {
+        const errors = [];
+        validateFlow([
+            {
+                id: 'custom_step',
+                type: 'custom_magic',
+                params: { anything: 'goes' },
+            },
+        ], errors);
+        // Should only have the "Unknown step type" error, not unknown params
+        expect(errors.length).toBe(1);
+        expect(errors[0]).toContain('Unknown step type: custom_magic');
+    });
+});

package/dist/__tests__/pack-versioning.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pack-versioning.test.d.ts.map

package/dist/__tests__/pack-versioning.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-versioning.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/pack-versioning.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/pack-versioning.test.js

@@ -0,0 +1,165 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { saveVersion, listVersions, restoreVersion, getVersionFiles } from '../packVersioning.js';
+function createTempPack(opts) {
+    const dir = join(tmpdir(), `test-pack-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    const taskpack = {
+        id: 'test-pack',
+        name: 'Test Pack',
+        version: opts?.version || '1.0.0',
+        kind: 'json-dsl',
+    };
+    writeFileSync(join(dir, 'taskpack.json'), JSON.stringify(taskpack, null, 2));
+    const flow = {
+        inputs: {},
+        collectibles: [],
+        flow: [{ id: 'step1', type: 'navigate', params: { url: 'https://example.com' } }],
+    };
+    writeFileSync(join(dir, 'flow.json'), JSON.stringify(flow, null, 2));
+    return dir;
+}
+describe('Pack Versioning', () => {
+    let packDir;
+    beforeEach(() => {
+        packDir = createTempPack();
+    });
+    afterEach(() => {
+        try {
+            rmSync(packDir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    });
+    it('saves a version and creates versioned files', () => {
+        const v = saveVersion(packDir, { source: 'cli', label: 'Initial' });
+        expect(v.number).toBe(1);
+        expect(v.version).toBe('1.0.0');
+        expect(v.source).toBe('cli');
+        expect(v.label).toBe('Initial');
+        expect(v.timestamp).toBeTruthy();
+        expect(existsSync(join(packDir, '.versions', '1.flow.json'))).toBe(true);
+        expect(existsSync(join(packDir, '.versions', '1.taskpack.json'))).toBe(true);
+        expect(existsSync(join(packDir, '.versions', 'manifest.json'))).toBe(true);
+    });
+    it('reads version field from taskpack.json metadata', () => {
+        const v = saveVersion(packDir, { source: 'dashboard' });
+        expect(v.version).toBe('1.0.0');
+        // Update version and save again
+        const taskpackPath = join(packDir, 'taskpack.json');
+        const taskpack = JSON.parse(readFileSync(taskpackPath, 'utf-8'));
+        taskpack.version = '2.0.0';
+        writeFileSync(taskpackPath, JSON.stringify(taskpack, null, 2));
+        const v2 = saveVersion(packDir, { source: 'cli' });
+        expect(v2.version).toBe('2.0.0');
+        expect(v2.number).toBe(2);
+    });
+    it('increments version numbers', () => {
+        const v1 = saveVersion(packDir, { source: 'cli' });
+        const v2 = saveVersion(packDir, { source: 'cli' });
+        const v3 = saveVersion(packDir, { source: 'cli' });
+        expect(v1.number).toBe(1);
+        expect(v2.number).toBe(2);
+        expect(v3.number).toBe(3);
+    });
+    it('lists versions', () => {
+        saveVersion(packDir, { source: 'cli', label: 'First' });
+        saveVersion(packDir, { source: 'dashboard', label: 'Second' });
+        const versions = listVersions(packDir);
+        expect(versions).toHaveLength(2);
+        expect(versions[0].label).toBe('First');
+        expect(versions[1].label).toBe('Second');
+    });
+    it('returns empty array when no versions exist', () => {
+        const versions = listVersions(packDir);
+        expect(versions).toEqual([]);
+    });
+    it('restores a version', () => {
+        // Save version 1 with original flow
+        saveVersion(packDir, { source: 'cli', label: 'Original' });
+        // Modify flow
+        const flowPath = join(packDir, 'flow.json');
+        const modified = {
+            inputs: {},
+            collectibles: [],
+            flow: [{ id: 'modified', type: 'navigate', params: { url: 'https://modified.com' } }],
+        };
+        writeFileSync(flowPath, JSON.stringify(modified, null, 2));
+        // Restore version 1
+        restoreVersion(packDir, 1);
+        // Root flow should match version 1
+        const restored = JSON.parse(readFileSync(flowPath, 'utf-8'));
+        expect(restored.flow[0].id).toBe('step1');
+        expect(restored.flow[0].params.url).toBe('https://example.com');
+    });
+    it('auto-saves current state before restoring', () => {
+        saveVersion(packDir, { source: 'cli', label: 'Original' });
+        // Modify flow
+        const flowPath = join(packDir, 'flow.json');
+        writeFileSync(flowPath, JSON.stringify({ flow: [{ id: 'new', type: 'navigate', params: { url: 'https://new.com' } }] }));
+        restoreVersion(packDir, 1);
+        // Should have 3 versions: original, auto-save, (version 1 was already there)
+        const versions = listVersions(packDir);
+        expect(versions).toHaveLength(2);
+        const autoSave = versions.find((v) => v.label?.includes('Auto-saved before restoring'));
+        expect(autoSave).toBeTruthy();
+    });
+    it('throws when restoring nonexistent version', () => {
+        expect(() => restoreVersion(packDir, 999)).toThrow('Version 999 not found');
+    });
+    it('getVersionFiles reads versioned files without restoring', () => {
+        saveVersion(packDir, { source: 'cli' });
+        // Modify current flow
+        const flowPath = join(packDir, 'flow.json');
+        writeFileSync(flowPath, JSON.stringify({ flow: [{ id: 'changed', type: 'navigate', params: { url: 'https://changed.com' } }] }));
+        // getVersionFiles should return the original
+        const files = getVersionFiles(packDir, 1);
+        expect(files.flow.flow[0].id).toBe('step1');
+        // Current flow should still be changed
+        const current = JSON.parse(readFileSync(flowPath, 'utf-8'));
+        expect(current.flow[0].id).toBe('changed');
+    });
+    it('throws when getting files for nonexistent version', () => {
+        expect(() => getVersionFiles(packDir, 999)).toThrow('Version 999 not found');
+    });
+    it('handles missing taskpack.json in old version gracefully', () => {
+        saveVersion(packDir, { source: 'cli' });
+        // Delete the versioned taskpack.json
+        const vTaskpack = join(packDir, '.versions', '1.taskpack.json');
+        rmSync(vTaskpack);
+        // getVersionFiles should still work with null taskpack
+        const files = getVersionFiles(packDir, 1);
+        expect(files.flow).toBeTruthy();
+        expect(files.taskpack).toBeNull();
+    });
+    it('prunes oldest versions when exceeding maxVersions', () => {
+        // Set a low maxVersions
+        const manifestPath = join(packDir, '.versions', 'manifest.json');
+        mkdirSync(join(packDir, '.versions'), { recursive: true });
+        writeFileSync(manifestPath, JSON.stringify({ versions: [], maxVersions: 3 }));
+        // Save 5 versions
+        for (let i = 0; i < 5; i++) {
+            saveVersion(packDir, { source: 'cli', label: `v${i}` });
+        }
+        const versions = listVersions(packDir);
+        expect(versions).toHaveLength(3);
+        // Oldest should have been pruned — remaining should be versions 3, 4, 5
+        expect(versions[0].number).toBe(3);
+        expect(versions[1].number).toBe(4);
+        expect(versions[2].number).toBe(5);
+        // Pruned versioned files should be deleted
+        expect(existsSync(join(packDir, '.versions', '1.flow.json'))).toBe(false);
+        expect(existsSync(join(packDir, '.versions', '2.flow.json'))).toBe(false);
+    });
+    it('saves conversationId when provided', () => {
+        const v = saveVersion(packDir, {
+            source: 'agent',
+            conversationId: 'conv-abc123',
+            label: 'Agent save',
+        });
+        expect(v.conversationId).toBe('conv-abc123');
+        const versions = listVersions(packDir);
+        expect(versions[0].conversationId).toBe('conv-abc123');
+    });
+});

package/dist/__tests__/validator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validator.test.d.ts.map

package/dist/__tests__/validator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/validator.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/validator.test.js

@@ -0,0 +1,149 @@
+import { describe, it, expect } from 'vitest';
+import { InputValidator } from '../validator.js';
+describe('InputValidator', () => {
+    describe('validate', () => {
+        it('passes for valid inputs with all required fields', () => {
+            const schema = { name: { type: 'string', required: true } };
+            expect(() => InputValidator.validate({ name: 'John' }, schema)).not.toThrow();
+        });
+        it('passes for valid inputs with optional fields omitted', () => {
+            const schema = {
+                name: { type: 'string', required: true },
+                age: { type: 'number', required: false },
+            };
+            expect(() => InputValidator.validate({ name: 'John' }, schema)).not.toThrow();
+        });
+        it('passes for valid inputs with optional fields provided', () => {
+            const schema = {
+                name: { type: 'string', required: true },
+                age: { type: 'number', required: false },
+            };
+            expect(() => InputValidator.validate({ name: 'John', age: 30 }, schema)).not.toThrow();
+        });
+        it('fails for missing required fields', () => {
+            const schema = { name: { type: 'string', required: true } };
+            expect(() => InputValidator.validate({}, schema)).toThrow(/Missing required field: name/);
+        });
+        it('fails for multiple missing required fields', () => {
+            const schema = {
+                name: { type: 'string', required: true },
+                email: { type: 'string', required: true },
+            };
+            expect(() => InputValidator.validate({}, schema)).toThrow(/Missing required field/);
+        });
+        it('fails for wrong type - string expected', () => {
+            const schema = { name: { type: 'string', required: true } };
+            expect(() => InputValidator.validate({ name: 123 }, schema)).toThrow(/must be a string/);
+        });
+        it('fails for wrong type - number expected', () => {
+            const schema = { age: { type: 'number', required: true } };
+            expect(() => InputValidator.validate({ age: 'thirty' }, schema)).toThrow(/must be a number/);
+        });
+        it('fails for wrong type - boolean expected', () => {
+            const schema = { enabled: { type: 'boolean', required: true } };
+            expect(() => InputValidator.validate({ enabled: 'true' }, schema)).toThrow(/must be a boolean/);
+        });
+        it('fails for unknown fields', () => {
+            const schema = { name: { type: 'string', required: true } };
+            expect(() => InputValidator.validate({ name: 'John', extra: 'field' }, schema)).toThrow(/Unknown field: extra/);
+        });
+        it('validates number type correctly', () => {
+            const schema = { count: { type: 'number', required: true } };
+            expect(() => InputValidator.validate({ count: 42 }, schema)).not.toThrow();
+            expect(() => InputValidator.validate({ count: 3.14 }, schema)).not.toThrow();
+        });
+        it('validates boolean type correctly', () => {
+            const schema = { active: { type: 'boolean', required: true } };
+            expect(() => InputValidator.validate({ active: true }, schema)).not.toThrow();
+            expect(() => InputValidator.validate({ active: false }, schema)).not.toThrow();
+        });
+        it('handles empty schema', () => {
+            const schema = {};
+            expect(() => InputValidator.validate({}, schema)).not.toThrow();
+        });
+        it('fails for empty inputs with unknown field on empty schema', () => {
+            const schema = {};
+            expect(() => InputValidator.validate({ foo: 'bar' }, schema)).toThrow(/Unknown field: foo/);
+        });
+    });
+    describe('applyDefaults', () => {
+        it('applies defaults for missing fields', () => {
+            const schema = { count: { type: 'number', default: 10 } };
+            expect(InputValidator.applyDefaults({}, schema)).toEqual({ count: 10 });
+        });
+        it('does not override provided values', () => {
+            const schema = { count: { type: 'number', default: 10 } };
+            expect(InputValidator.applyDefaults({ count: 5 }, schema)).toEqual({ count: 5 });
+        });
+        it('applies string defaults', () => {
+            const schema = { name: { type: 'string', default: 'Anonymous' } };
+            expect(InputValidator.applyDefaults({}, schema)).toEqual({ name: 'Anonymous' });
+        });
+        it('applies boolean defaults', () => {
+            const schema = { enabled: { type: 'boolean', default: true } };
+            expect(InputValidator.applyDefaults({}, schema)).toEqual({ enabled: true });
+        });
+        it('applies false boolean default', () => {
+            const schema = { enabled: { type: 'boolean', default: false } };
+            expect(InputValidator.applyDefaults({}, schema)).toEqual({ enabled: false });
+        });
+        it('does not apply default when value is explicitly false', () => {
+            const schema = { enabled: { type: 'boolean', default: true } };
+            expect(InputValidator.applyDefaults({ enabled: false }, schema)).toEqual({ enabled: false });
+        });
+        it('does not apply default when value is explicitly 0', () => {
+            const schema = { count: { type: 'number', default: 10 } };
+            expect(InputValidator.applyDefaults({ count: 0 }, schema)).toEqual({ count: 0 });
+        });
+        it('does not apply default when value is explicitly empty string', () => {
+            const schema = { name: { type: 'string', default: 'default' } };
+            expect(InputValidator.applyDefaults({ name: '' }, schema)).toEqual({ name: '' });
+        });
+        it('applies multiple defaults', () => {
+            const schema = {
+                name: { type: 'string', default: 'User' },
+                count: { type: 'number', default: 1 },
+                active: { type: 'boolean', default: true },
+            };
+            expect(InputValidator.applyDefaults({}, schema)).toEqual({
+                name: 'User',
+                count: 1,
+                active: true,
+            });
+        });
+        it('applies only missing defaults', () => {
+            const schema = {
+                name: { type: 'string', default: 'User' },
+                count: { type: 'number', default: 1 },
+                active: { type: 'boolean', default: true },
+            };
+            expect(InputValidator.applyDefaults({ name: 'Custom' }, schema)).toEqual({
+                name: 'Custom',
+                count: 1,
+                active: true,
+            });
+        });
+        it('does not add fields without defaults', () => {
+            const schema = {
+                name: { type: 'string', required: true },
+                count: { type: 'number', default: 10 },
+            };
+            expect(InputValidator.applyDefaults({}, schema)).toEqual({ count: 10 });
+        });
+        it('preserves existing fields not in schema', () => {
+            const schema = { count: { type: 'number', default: 10 } };
+            expect(InputValidator.applyDefaults({ extra: 'value' }, schema)).toEqual({
+                extra: 'value',
+                count: 10,
+            });
+        });
+        it('returns new object without modifying input', () => {
+            const schema = { count: { type: 'number', default: 10 } };
+            const original = { name: 'test' };
+            const result = InputValidator.applyDefaults(original, schema);
+            expect(result).not.toBe(original);
+            expect(original).toEqual({ name: 'test' });
+            expect(result).toEqual({ name: 'test', count: 10 });
+        });
+    });
+});