@ecopages/core 0.2.0-alpha.7 → 0.2.0-alpha.8

package/src/services/validation/schema-validation-service.test.ts

@@ -1,223 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import { z } from 'zod';
-import * as v from 'valibot';
-import { type } from 'arktype';
-import { SchemaValidationService } from './schema-validation-service.ts';
-
-describe('SchemaValidationService', () => {
-	const service = new SchemaValidationService();
-
-	describe('Zod validation', () => {
-		test('validates body with Zod schema', async () => {
-			const schema = z.object({
-				title: z.string().min(1),
-				count: z.number(),
-			});
-
-			const result = await service.validateRequest(
-				{ body: { title: 'Hello', count: 42 } },
-				{ body: schema as unknown as Parameters<typeof service.validateRequest>[1]['body'] },
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.body).toEqual({ title: 'Hello', count: 42 });
-		});
-
-		test('rejects invalid body with Zod schema', async () => {
-			const schema = z.object({
-				title: z.string().min(1),
-				count: z.number(),
-			});
-
-			const result = await service.validateRequest(
-				{ body: { title: '', count: 'not-a-number' } },
-				{ body: schema as unknown as Parameters<typeof service.validateRequest>[1]['body'] },
-			);
-
-			expect(result.success).toBe(false);
-			expect(result.errors).toBeDefined();
-			expect(result.errors!.length).toBeGreaterThan(0);
-		});
-	});
-
-	describe('Valibot validation', () => {
-		test('validates query with Valibot schema', async () => {
-			const schema = v.object({
-				page: v.string(),
-				limit: v.string(),
-			});
-
-			const result = await service.validateRequest(
-				{ query: { page: '1', limit: '10' } },
-				{ query: schema as unknown as Parameters<typeof service.validateRequest>[1]['query'] },
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.query).toEqual({ page: '1', limit: '10' });
-		});
-
-		test('rejects invalid query with Valibot schema', async () => {
-			const schema = v.object({
-				page: v.pipe(v.string(), v.minLength(1)),
-			});
-
-			const result = await service.validateRequest(
-				{ query: { page: '' } },
-				{ query: schema as unknown as Parameters<typeof service.validateRequest>[1]['query'] },
-			);
-
-			expect(result.success).toBe(false);
-			expect(result.errors).toBeDefined();
-		});
-	});
-
-	describe('ArkType validation', () => {
-		test('validates headers with ArkType schema', async () => {
-			const schema = type({
-				'content-type': 'string',
-				authorization: 'string',
-			});
-
-			const result = await service.validateRequest(
-				{
-					headers: {
-						'content-type': 'application/json',
-						authorization: 'Bearer token',
-					},
-				},
-				{ headers: schema as unknown as Parameters<typeof service.validateRequest>[1]['headers'] },
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.headers).toEqual({
-				'content-type': 'application/json',
-				authorization: 'Bearer token',
-			});
-		});
-
-		test('rejects invalid headers with ArkType schema', async () => {
-			const schema = type({
-				'content-type': 'string',
-				'x-custom': 'string>5',
-			});
-
-			const result = await service.validateRequest(
-				{
-					headers: {
-						'content-type': 'application/json',
-						'x-custom': 'ab',
-					},
-				},
-				{ headers: schema as unknown as Parameters<typeof service.validateRequest>[1]['headers'] },
-			);
-
-			expect(result.success).toBe(false);
-			expect(result.errors).toBeDefined();
-		});
-	});
-
-	describe('Combined validation', () => {
-		test('validates multiple sources at once', async () => {
-			const bodySchema = z.object({
-				title: z.string(),
-			});
-			const querySchema = v.object({
-				format: v.string(),
-			});
-
-			const result = await service.validateRequest(
-				{
-					body: { title: 'Post Title' },
-					query: { format: 'json' },
-				},
-				{
-					body: bodySchema as unknown as Parameters<typeof service.validateRequest>[1]['body'],
-					query: querySchema as unknown as Parameters<typeof service.validateRequest>[1]['query'],
-				},
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.body).toEqual({ title: 'Post Title' });
-			expect(result.data?.query).toEqual({ format: 'json' });
-		});
-
-		test('validates route params with schema', async () => {
-			const paramsSchema = z.object({
-				id: z.coerce.number().int(),
-			});
-
-			const result = await service.validateRequest(
-				{
-					params: { id: '42' },
-				},
-				{
-					params: paramsSchema as unknown as Parameters<typeof service.validateRequest>[1]['params'],
-				},
-			);
-
-			expect(result.success).toBe(true);
-			expect(result.data?.params).toEqual({ id: 42 });
-		});
-
-		test('aggregates errors from multiple sources', async () => {
-			const bodySchema = z.object({
-				title: z.string().min(5),
-			});
-			const querySchema = v.object({
-				page: v.pipe(v.string(), v.regex(/^\d+$/)),
-			});
-
-			const result = await service.validateRequest(
-				{
-					body: { title: 'ab' },
-					query: { page: 'invalid' },
-				},
-				{
-					body: bodySchema as unknown as Parameters<typeof service.validateRequest>[1]['body'],
-					query: querySchema as unknown as Parameters<typeof service.validateRequest>[1]['query'],
-				},
-			);
-
-			expect(result.success).toBe(false);
-			expect(result.errors).toBeDefined();
-			expect(result.errors!.length).toBeGreaterThan(1);
-		});
-	});
-
-	describe('Edge cases', () => {
-		test('handles missing optional schemas', async () => {
-			const result = await service.validateRequest({ body: { data: 'test' } }, {});
-
-			expect(result.success).toBe(true);
-			expect(result.data).toEqual({});
-		});
-
-		test('handles undefined source data', async () => {
-			const schema = z.object({ name: z.string() });
-
-			const result = await service.validateRequest(
-				{ body: undefined },
-				{ body: schema as unknown as Parameters<typeof service.validateRequest>[1]['body'] },
-			);
-
-			expect(result.success).toBe(true);
-		});
-
-		test('catches validation exceptions', async () => {
-			const brokenSchema = {
-				'~standard': {
-					version: 1,
-					vendor: 'test',
-					validate: () => {
-						throw new Error('Validation crashed');
-					},
-				},
-			} as const;
-
-			const result = await service.validateRequest({ body: { test: true } }, { body: brokenSchema });
-
-			expect(result.success).toBe(false);
-			expect(result.errors?.[0]?.message).toBe('Validation crashed');
-		});
-	});
-});

package/src/static-site-generator/static-site-generator.test.ts

@@ -1,307 +0,0 @@
-import { describe, expect, test, beforeEach, afterEach, vi } from 'vitest';
-import { fileSystem } from '@ecopages/file-system';
-import { StaticSiteGenerator } from './static-site-generator';
-import type { EcoPagesAppConfig } from '../internal-types';
-import type { FSRouter } from '../router/server/fs-router';
-import type { RouteRendererFactory } from '../route-renderer/route-renderer';
-import { appLogger } from '../global/app-logger.ts';
-import { PageModuleImportService } from '../services/module-loading/page-module-import.service';
-import { DEFAULT_ECOPAGES_WORK_DIR } from '../constants.ts';
-
-const originalEnsureDir = fileSystem.ensureDir;
-const originalWrite = fileSystem.write;
-
-const createMockConfig = (overrides: Partial<EcoPagesAppConfig> = {}): EcoPagesAppConfig =>
-	({
-		rootDir: '/test/project',
-		distDir: 'dist',
-		workDir: DEFAULT_ECOPAGES_WORK_DIR,
-		srcDir: 'src',
-		robotsTxt: {
-			preferences: {
-				'*': ['/admin', '/private'],
-				Googlebot: ['/no-google'],
-			},
-		},
-		absolutePaths: {
-			distDir: '/test/project/dist',
-			workDir: '/test/project/.eco',
-		} as EcoPagesAppConfig['absolutePaths'],
-		integrations: [],
-		...overrides,
-	}) as EcoPagesAppConfig;
-
-describe('StaticSiteGenerator', () => {
-	let ensureDirMock: any;
-	let writeMock: any;
-
-	beforeEach(() => {
-		ensureDirMock = vi.fn(() => {});
-		writeMock = vi.fn(() => {});
-		fileSystem.ensureDir = ensureDirMock;
-		fileSystem.write = writeMock;
-		vi.spyOn(PageModuleImportService.prototype, 'importModule').mockResolvedValue({
-			default: Object.assign(() => null, { cache: 'static' }),
-		});
-		vi.spyOn(appLogger, 'warn').mockReturnValue(appLogger);
-	});
-
-	afterEach(() => {
-		fileSystem.ensureDir = originalEnsureDir;
-		fileSystem.write = originalWrite;
-		vi.restoreAllMocks();
-	});
-
-	describe('constructor', () => {
-		test('should create instance with appConfig', () => {
-			const config = createMockConfig();
-			const ssg = new StaticSiteGenerator({ appConfig: config });
-			expect(ssg.appConfig).toBe(config);
-		});
-	});
-
-	describe('isRootDir', () => {
-		test('should return true for root path /', () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			expect(ssg.isRootDir('/')).toBe(true);
-		});
-
-		test('should return false for nested path /foo/bar', () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			expect(ssg.isRootDir('/foo/bar')).toBe(false);
-		});
-
-		test('should return false for deeply nested paths', () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			expect(ssg.isRootDir('/a/b/c/d')).toBe(false);
-		});
-
-		test('should return null (falsy) for paths without slashes', () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			expect(ssg.isRootDir('no-slashes')).toBeFalsy();
-		});
-	});
-
-	describe('getDirectories', () => {
-		test('should return empty array for root-level routes', () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const dirs = ssg.getDirectories(['/about', '/contact']);
-			expect(dirs).toEqual([]);
-		});
-
-		test('should extract directories from nested routes', () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const dirs = ssg.getDirectories(['/blog/post-1', '/blog/post-2', '/docs/api']);
-			expect(dirs).toContain('/blog');
-			expect(dirs).toContain('/docs');
-		});
-
-		test('should handle HTTP URLs and extract pathname', () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const dirs = ssg.getDirectories(['http://localhost:3000/blog/post']);
-			expect(dirs).toContain('/blog');
-		});
-
-		test('should deduplicate directories', () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const dirs = ssg.getDirectories(['/blog/a', '/blog/b', '/blog/c']);
-			expect(dirs.filter((d) => d === '/blog').length).toBe(1);
-		});
-
-		test('should handle deeply nested paths', () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const dirs = ssg.getDirectories(['/a/b/c/page']);
-			expect(dirs).toContain('/a/b/c');
-		});
-	});
-
-	describe('generateRobotsTxt', () => {
-		test('should generate robots.txt with preferences from config', () => {
-			const config = createMockConfig();
-			const ssg = new StaticSiteGenerator({ appConfig: config });
-
-			ssg.generateRobotsTxt();
-
-			expect(ensureDirMock).toHaveBeenCalledWith('/test/project/dist');
-			expect(writeMock).toHaveBeenCalledWith('/test/project/dist/robots.txt', expect.any(String));
-
-			const writtenContent = writeMock.mock.calls[0][1] as string;
-			expect(writtenContent).toContain('user-agent: *');
-			expect(writtenContent).toContain('disallow: /admin');
-			expect(writtenContent).toContain('disallow: /private');
-			expect(writtenContent).toContain('user-agent: Googlebot');
-			expect(writtenContent).toContain('disallow: /no-google');
-		});
-
-		test('should handle empty preferences', () => {
-			const config = createMockConfig({
-				robotsTxt: { preferences: {} },
-			});
-			const ssg = new StaticSiteGenerator({ appConfig: config });
-
-			ssg.generateRobotsTxt();
-
-			expect(writeMock).toHaveBeenCalledWith('/test/project/dist/robots.txt', '');
-		});
-	});
-
-	describe('generateStaticPages', () => {
-		const createMockRouter = (routes: Record<string, { filePath: string; pathname: string }>) =>
-			({
-				routes: Object.fromEntries(
-					Object.entries(routes).map(([key, value]) => [key, { ...value, kind: 'exact' }]),
-				),
-				origin: 'http://localhost:3000',
-			}) as unknown as FSRouter;
-
-		test('should filter out dynamic routes containing [', async () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const Router = createMockRouter({
-				'/static': { filePath: '/src/pages/static.ghtml.ts', pathname: '/static' },
-				'/dynamic/[id]': { filePath: '/src/pages/dynamic/[id].ghtml.ts', pathname: '/dynamic/[id]' },
-			});
-
-			const RendererFactory = {
-				createRenderer: vi.fn(() => ({
-					createRoute: vi.fn(async () => ({ body: '<html>Static</html>' })),
-				})),
-			} as unknown as RouteRendererFactory;
-
-			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
-
-			expect(writeMock).toHaveBeenCalledTimes(1);
-		});
-
-		test('should create directories for nested routes', async () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const Router = createMockRouter({
-				'/blog/post': { filePath: '/src/pages/blog/post.ghtml.ts', pathname: '/blog/post' },
-			});
-
-			const RendererFactory = {
-				createRenderer: vi.fn(() => ({
-					createRoute: vi.fn(async () => ({ body: '<html>Blog Post</html>' })),
-				})),
-			} as unknown as RouteRendererFactory;
-
-			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
-
-			expect(ensureDirMock).toHaveBeenCalled();
-		});
-
-		test('should throw error when routeRendererFactory is missing for render strategy', async () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const Router = createMockRouter({
-				'/page': { filePath: '/src/pages/page.ghtml.ts', pathname: '/page' },
-			});
-
-			await ssg.generateStaticPages(Router, 'http://localhost:3000', undefined);
-		});
-
-		test('should write index.html for root path', async () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const Router = createMockRouter({
-				'/': { filePath: '/src/pages/index.ghtml.ts', pathname: '/' },
-			});
-
-			const RendererFactory = {
-				createRenderer: vi.fn(() => ({
-					createRoute: vi.fn(async () => ({ body: '<html>Home</html>' })),
-				})),
-			} as unknown as RouteRendererFactory;
-
-			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
-
-			expect(writeMock).toHaveBeenCalledWith(expect.stringContaining('index.html'), '<html>Home</html>');
-		});
-
-		test('should handle Buffer content from renderer', async () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const Router = createMockRouter({
-				'/': { filePath: '/src/pages/index.ghtml.ts', pathname: '/' },
-			});
-
-			const bufferContent = Buffer.from('<html>Buffer Content</html>');
-			const RendererFactory = {
-				createRenderer: vi.fn(() => ({
-					createRoute: vi.fn(async () => ({ body: bufferContent })),
-				})),
-			} as unknown as RouteRendererFactory;
-
-			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
-
-			expect(writeMock).toHaveBeenCalledWith(expect.stringContaining('index.html'), bufferContent);
-		});
-
-		test('should skip cache dynamic pages during static generation and log a warning', async () => {
-			vi.spyOn(PageModuleImportService.prototype, 'importModule').mockResolvedValue({
-				default: Object.assign(() => null, { cache: 'dynamic' }),
-			});
-
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const Router = createMockRouter({
-				'/dashboard': { filePath: '/src/pages/dashboard.tsx', pathname: '/dashboard' },
-			});
-
-			const RendererFactory = {
-				createRenderer: vi.fn(() => ({
-					createRoute: vi.fn(async () => ({ body: '<html>Dashboard</html>' })),
-				})),
-			} as unknown as RouteRendererFactory;
-
-			await ssg.generateStaticPages(Router, 'http://localhost:3000', RendererFactory);
-
-			expect(RendererFactory.createRenderer).not.toHaveBeenCalled();
-			expect(writeMock).not.toHaveBeenCalled();
-			expect(appLogger.warn).toHaveBeenCalledWith(
-				"Pages with cache: 'dynamic' are not supported in static generation or preview, so they will be skipped\n",
-				'➤ /src/pages/dashboard.tsx',
-			);
-		});
-	});
-
-	describe('run', () => {
-		test('should call generateRobotsTxt and generateStaticPages', async () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const Router = {
-				routes: {},
-				origin: 'http://localhost:3000',
-			} as unknown as FSRouter;
-
-			await ssg.run({
-				router: Router,
-				baseUrl: 'http://localhost:3000',
-			});
-
-			expect(ensureDirMock).toHaveBeenCalled();
-			expect(writeMock).toHaveBeenCalledWith('/test/project/dist/robots.txt', expect.any(String));
-		});
-
-		test('should skip explicit static routes backed by cache dynamic views', async () => {
-			const ssg = new StaticSiteGenerator({ appConfig: createMockConfig() });
-			const dynamicView = Object.assign(() => null, { cache: 'dynamic' }) as any;
-
-			await ssg.run({
-				router: {
-					routes: {},
-					origin: 'http://localhost:3000',
-				} as unknown as FSRouter,
-				baseUrl: 'http://localhost:3000',
-				routeRendererFactory: {
-					getRendererByIntegration: vi.fn(),
-				} as unknown as RouteRendererFactory,
-				staticRoutes: [
-					{
-						path: '/dashboard',
-						loader: async () => ({ default: dynamicView }),
-					},
-				],
-			});
-
-			expect(appLogger.warn).toHaveBeenCalledWith(
-				"Pages with cache: 'dynamic' are not supported in static generation or preview, so they will be skipped\n",
-				'➤ /dashboard',
-			);
-		});
-	});
-});

package/src/utils/deep-merge.test.ts

@@ -1,114 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { deepMerge } from './deep-merge.ts';
-
-describe('deepMerge', () => {
-	it('should merge two objects with nested properties', () => {
-		const target = { a: 1, b: { c: 2 } };
-		const source = { b: { d: 3 }, e: 4 };
-		const expected = { a: 1, b: { c: 2, d: 3 }, e: 4 };
-		const result = deepMerge(target, source);
-		expect(result).toEqual(expected);
-	});
-
-	it('should merge two objects with overlapping properties', () => {
-		const target = { a: 1, b: 2 };
-		const source = { b: 3, c: 4 };
-		const expected = { a: 1, b: 3, c: 4 };
-		const result = deepMerge(target, source);
-		expect(result).toEqual(expected);
-	});
-
-	it('should merge two objects with arrays', () => {
-		const target = { a: [1, 2], b: { c: [3, 4] } };
-		const source = { a: [5, 6], b: { c: [7, 8] } };
-		const expected = { a: [1, 2, 5, 6], b: { c: [3, 4, 7, 8] } };
-		const result = deepMerge(target, source);
-		expect(result).toEqual(expected);
-	});
-
-	it('should merge two objects with nested objects', () => {
-		const target = { a: { b: 1, c: 2 }, d: 3 };
-		const source = { a: { c: 3, d: 4 }, e: 5 };
-		const expected = { a: { b: 1, c: 3, d: 4 }, d: 3, e: 5 };
-		const result = deepMerge(target, source);
-		expect(result).toEqual(expected);
-	});
-
-	it('should overwrite non-object properties in the target', () => {
-		const target = { a: 1, b: 2 };
-		const source = { a: 3, c: 4 };
-		const expected = { a: 3, b: 2, c: 4 };
-		const result = deepMerge(target, source);
-		expect(result).toEqual(expected);
-	});
-
-	it('should add properties from the source that are not in the target', () => {
-		const target = { a: 1 };
-		const source = { b: 2 };
-		const expected = { a: 1, b: 2 };
-		const result = deepMerge(target, source);
-		expect(result).toEqual(expected);
-	});
-
-	it('should return an empty object when both inputs are empty', () => {
-		const target = {};
-		const source = {};
-		const expected = {};
-		const result = deepMerge(target, source);
-		expect(result).toEqual(expected);
-	});
-
-	it('should ignore properties in the source that are undefined', () => {
-		const target = { a: 1, b: 2 };
-		const source = { a: undefined, c: 3 } as Partial<typeof target>;
-		const expected = { a: 1, b: 2, c: 3 };
-		const result = deepMerge(target, source);
-		expect(result).toEqual(expected);
-	});
-
-	it('should merge dependencies', () => {
-		const depsA = {
-			stylesheets: ['/components/radiant-counter/radiant-counter.css'],
-			scripts: ['/components/radiant-counter/radiant-counter.script.ts'],
-		};
-
-		const depsB = {
-			stylesheets: [
-				'/layouts/docs-layout/docs-layout.css',
-				'/layouts/base-layout/base-layout.css',
-				'/components/header/header.css',
-				'/components/navigation/navigation.css',
-				'/components/logo/logo.css',
-				'/components/code-block/code-block.css',
-			],
-			scripts: ['/layouts/base-layout/base-layout.script.ts'],
-		};
-
-		const expected = {
-			stylesheets: [
-				'/components/radiant-counter/radiant-counter.css',
-				'/layouts/docs-layout/docs-layout.css',
-				'/layouts/base-layout/base-layout.css',
-				'/components/header/header.css',
-				'/components/navigation/navigation.css',
-				'/components/logo/logo.css',
-				'/components/code-block/code-block.css',
-			],
-			scripts: [
-				'/components/radiant-counter/radiant-counter.script.ts',
-				'/layouts/base-layout/base-layout.script.ts',
-			],
-		};
-
-		const result = deepMerge(depsA, depsB);
-		expect(result).toEqual(expected);
-	});
-
-	it('should merge two arrays', () => {
-		const target = [1, 2, 3];
-		const source = [4, 5, 6];
-		const expected = [1, 2, 3, 4, 5, 6];
-		const result = deepMerge(target, source);
-		expect(result).toEqual(expected);
-	});
-});

package/src/utils/invariant.test.ts

@@ -1,22 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { invariant } from './invariant.ts';
-
-describe('invariant', () => {
-	test('should not throw an error when the condition is true', () => {
-		expect(() => {
-			invariant(true);
-		}).not.toThrow();
-	});
-
-	test('should throw an error with the default message when the condition is false', () => {
-		expect(() => {
-			invariant(false);
-		}).toThrowError('[ecopages] An error occurred');
-	});
-
-	test('should throw an error with the provided message when the condition is false', () => {
-		expect(() => {
-			invariant(false, 'Custom error message');
-		}).toThrowError('[ecopages] Custom error message');
-	});
-});

package/src/utils/path-utils.test.ts

@@ -1,15 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { PathUtils } from './path-utils.module.ts';
-
-describe('PathUtils', () => {
-	test.each([
-		['packages/core/src/utils/file-name-analyzer.ts', '.ts'],
-		['packages/playground/src/pages/blog/author/%5Bid%5D.kita.tsx', '.kita.tsx'],
-		['packages/core/src/component-utils/deps-manager.ts', '.ts'],
-		['/packages/core/src/plugins/build-html-pages/build-html-pages.plugin.ts', '.plugin.ts'],
-		['packages/core/src/ecopages.fake.descriptor.ts', '.descriptor.ts'],
-	])('getEcoTemplateExtension: %p should return %p', (filePath, expected) => {
-		const result = PathUtils.getEcoTemplateExtension(filePath);
-		expect(result).toBe(expected);
-	});
-});