@jjlmoya/utils-drones 1.1.0

package/src/tests/faq_count.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from 'vitest';
+import type * as DATA from '../data';
+
+const TOOLS: typeof DATA.dronesCategory[] = [];
+
+describe('FAQ Content Validation', () => {
+  TOOLS.forEach((entry) => {
+    describe(`Tool: ${entry.icon}`, () => {
+      it('placeholder', () => {
+        expect(true).toBe(true);
+      });
+    });
+  });
+
+  it('no tools registered yet', () => {
+    expect(TOOLS.length).toBe(0);
+  });
+});
+

package/src/tests/locale_completeness.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+describe('Locale Completeness Validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(tool.entry.i18n).forEach((locale) => {
+        describe(`Locale: ${locale}`, () => {
+          it('faqTitle should be defined when faq items exist', async () => {
+            const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+            const content = (await loader?.()) as ToolLocaleContent;
+
+            if (content.faq.length > 0) {
+              expect(
+                content.faqTitle,
+                `Tool "${tool.entry.id}" locale "${locale}" has ${content.faq.length} FAQ items but is missing faqTitle`,
+              ).toBeTruthy();
+            }
+          });
+
+          it('bibliographyTitle should be defined when bibliography items exist', async () => {
+            const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+            const content = (await loader?.()) as ToolLocaleContent;
+
+            if (content.bibliography.length > 0) {
+              expect(
+                content.bibliographyTitle,
+                `Tool "${tool.entry.id}" locale "${locale}" has ${content.bibliography.length} bibliography items but is missing bibliographyTitle`,
+              ).toBeTruthy();
+            }
+          });
+        });
+      });
+    });
+  });
+
+  it('all tools are registered', () => {
+    expect(ALL_TOOLS.length).toBeGreaterThan(0);
+  });
+});
+

package/src/tests/mocks/astro_mock.js

@@ -0,0 +1,2 @@
+export default function () { return null; }
+

package/src/tests/no_h1_in_components.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const EXCLUDED_DIRS = ['node_modules', 'pages', 'layouts'];
+
+function findAstroFiles(dir: string): string[] {
+  const files: string[] = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory() && !EXCLUDED_DIRS.includes(entry.name)) {
+      files.push(...findAstroFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith('.astro')) {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+function hasH1(content: string): boolean {
+  return /<h1[\s>]/i.test(content);
+}
+
+const srcDir = join(process.cwd(), 'src');
+const astroFiles = findAstroFiles(srcDir);
+
+describe('No H1 in Components', () => {
+  if (astroFiles.length === 0) {
+    it('no astro components found', () => {
+      expect(true).toBe(true);
+    });
+  }
+
+  astroFiles.forEach((file) => {
+    const relativePath = file.replace(process.cwd(), '');
+    it(`${relativePath} should not contain <h1>`, () => {
+      const content = readFileSync(file, 'utf-8');
+      expect(
+        hasH1(content),
+        `File "${relativePath}" contains a <h1> element. Use <h2> or lower inside components — h1 belongs to the page layout.`,
+      ).toBe(false);
+    });
+  });
+});
+

package/src/tests/seo_length.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import * as DATA from '../data';
+
+const ENTRIES = [
+  { id: 'dronesCategory', i18n: DATA.dronesCategory.i18n },
+];
+
+describe('SEO Content Length Validation', () => {
+  ENTRIES.forEach((entry) => {
+    describe(`Tool: ${entry.id}`, () => {
+      Object.keys(entry.i18n).forEach((locale) => {
+        it(`${locale}: SEO section should exist`, async () => {
+          const loader = (entry.i18n as Record<string, () => Promise<{ seo?: unknown[] }>>)[locale];
+          const content = await loader();
+          if (!content.seo) return;
+          expect(Array.isArray(content.seo)).toBe(true);
+        });
+      });
+    });
+  });
+});
+

package/src/tests/seo_section_types.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { dronesCategory } from '../category';
+import { droneFlightTime } from '../tool/drone-flight-time';
+import { antennaLengthCalculator } from '../tool/antenna-length-calculator';
+import { gpsCoordinatesConverter } from '../tool/gps-coordinates-converter';
+
+const SUPPORTED_TYPES = new Set([
+  'title',
+  'paragraph',
+  'list',
+  'table',
+  'tip',
+  'card',
+  'stats',
+  'glossary',
+  'code',
+  'comparative',
+  'diagnostic',
+  'proscons',
+  'summary',
+  'grid',
+  'message',
+]);
+
+const ENTRIES = [
+  { id: 'dronesCategory', i18n: dronesCategory.i18n, isTool: false },
+  { id: 'droneFlightTime', i18n: droneFlightTime.i18n, isTool: true },
+  { id: 'antennaLengthCalculator', i18n: antennaLengthCalculator.i18n, isTool: true },
+  { id: 'gpsCoordinatesConverter', i18n: gpsCoordinatesConverter.i18n, isTool: true },
+];
+
+describe('SEO Section Types Validation', () => {
+  ENTRIES.forEach((entry) => {
+    describe(`${entry.isTool ? 'Tool' : 'Category'}: ${entry.id}`, () => {
+      Object.keys(entry.i18n).forEach((locale) => {
+        it(`${locale}: All SEO section types should be supported and mapped`, async () => {
+          const loader = (entry.i18n as Record<string, () => Promise<{ seo?: unknown[] }>>)[locale];
+          const content = await loader();
+
+          if (!content.seo || !Array.isArray(content.seo)) {
+            return;
+          }
+
+          const foundTypes = new Set<string>();
+          const unsupportedTypes: { type: string; section: unknown }[] = [];
+
+          content.seo.forEach((section: any) => {
+            const sectionType = section.type;
+            if (!sectionType) {
+              unsupportedTypes.push({ type: 'UNDEFINED', section });
+              return;
+            }
+
+            foundTypes.add(sectionType);
+
+            if (!SUPPORTED_TYPES.has(sectionType)) {
+              unsupportedTypes.push({ type: sectionType, section });
+            }
+          });
+
+          if (unsupportedTypes.length > 0) {
+            const typesList = unsupportedTypes.map((u) => `"${u.type}"`).join(', ');
+            expect.fail(
+              `Found unmapped SEO section types in ${entry.id} (${locale}): ${typesList}\n` +
+              `Please add handlers for these types in seo.astro or update SUPPORTED_TYPES if they're intentionally missing.\n` +
+              `Unmapped sections:\n${JSON.stringify(unsupportedTypes, null, 2)}`
+            );
+          }
+
+          expect(foundTypes.size).toBeGreaterThan(0);
+        });
+      });
+    });
+  });
+});

package/src/tests/tool_validation.test.ts

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import { dronesCategory } from '../data';
+
+describe('Tool Validation Suite', () => {
+  describe('Library Registration', () => {
+    it('should have 3 tools in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBe(3);
+    });
+
+    it('dronesCategory should be defined', () => {
+      expect(dronesCategory).toBeDefined();
+      expect(dronesCategory.i18n).toBeDefined();
+    });
+  });
+});
+