test(archive): add import/export round-trip and store tests

Add unit tests for archive utilities and store actions:
- createArchive produces valid ZIP blob
- extractArchive reads back model, template, and data
- extractArchive throws on missing model or grammar files
- Name extraction from description field
- Full round-trip data preservation
- exportTemplate creates archive and triggers download
- importTemplate updates store state with extracted data
- Error handling for both store actions

Signed-off-by: Shubh-Raj <shubhraj625@gmail.com>

Author: Shubh-Raj

src/tests/store/importExport.test.tsx

@@ -0,0 +1,76 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import useAppStore from '../../store/store';
+
+vi.mock('../../utils/archive/archive', () => ({
+  createArchive: vi.fn(),
+  extractArchive: vi.fn(),
+  downloadBlob: vi.fn(),
+}));
+
+import { createArchive, extractArchive, downloadBlob } from '../../utils/archive/archive';
+
+describe('useAppStore - import/export', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('exportTemplate', () => {
+    it('should create archive and trigger download', async () => {
+      const mockBlob = new Blob(['test']);
+      vi.mocked(createArchive).mockResolvedValue(mockBlob);
+
+      useAppStore.setState({
+        sampleName: 'Test',
+        modelCto: 'model',
+        templateMarkdown: 'template',
+        data: '{}',
+      });
+
+      await useAppStore.getState().exportTemplate();
+
+      expect(createArchive).toHaveBeenCalledWith('Test', 'model', 'template', '{}');
+      expect(downloadBlob).toHaveBeenCalledWith(mockBlob, 'test.cta');
+    });
+
+    it('should set error on failure', async () => {
+      vi.mocked(createArchive).mockRejectedValue(new Error('zip failed'));
+
+      await useAppStore.getState().exportTemplate();
+
+      const state = useAppStore.getState();
+      expect(state.error).toContain('Failed to export template');
+      expect(state.isProblemPanelVisible).toBe(true);
+    });
+  });
+
+  describe('importTemplate', () => {
+    it('should extract archive and update store state', async () => {
+      vi.mocked(extractArchive).mockResolvedValue({
+        name: 'Imported',
+        model: 'new model',
+        template: 'new template',
+        data: '{"key":"value"}',
+      });
+
+      const file = new File(['fake'], 'test.cta');
+      await useAppStore.getState().importTemplate(file);
+
+      const state = useAppStore.getState();
+      expect(state.sampleName).toBe('Imported');
+      expect(state.modelCto).toBe('new model');
+      expect(state.templateMarkdown).toBe('new template');
+      expect(state.data).toBe('{"key":"value"}');
+    });
+
+    it('should set error on failure', async () => {
+      vi.mocked(extractArchive).mockRejectedValue(new Error('invalid cta'));
+
+      const file = new File(['bad'], 'bad.cta');
+      await expect(useAppStore.getState().importTemplate(file)).rejects.toThrow('invalid cta');
+
+      const state = useAppStore.getState();
+      expect(state.error).toContain('Failed to import template');
+      expect(state.isProblemPanelVisible).toBe(true);
+    });
+  });
+});

src/tests/utils/archive.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest';
+import { createArchive, extractArchive } from '../../utils/archive/archive';
+
+describe('Archive Utilities', () => {
+  const mockData = {
+    name: 'Test Template',
+    model: 'namespace test@1.0.0\nconcept Data { o String value }',
+    template: '# Hello {{value}}',
+    data: JSON.stringify({ $class: 'test@1.0.0.Data', value: 'World' }),
+  };
+
+  describe('createArchive', () => {
+    it('should create a valid ZIP blob', async () => {
+      const blob = await createArchive(
+        mockData.name,
+        mockData.model,
+        mockData.template,
+        mockData.data
+      );
+      expect(blob).toBeInstanceOf(Blob);
+      expect(blob.size).toBeGreaterThan(0);
+    });
+  });
+
+  describe('extractArchive', () => {
+    it('should extract template data from archive', async () => {
+      const blob = await createArchive(
+        mockData.name,
+        mockData.model,
+        mockData.template,
+        mockData.data
+      );
+      const file = new File([blob], 'test.cta', { type: 'application/zip' });
+      const extracted = await extractArchive(file);
+
+      expect(extracted.model).toBe(mockData.model);
+      expect(extracted.template).toBe(mockData.template);
+      expect(extracted.data).toBe(mockData.data);
+    });
+
+    it('should extract human-readable name from description field', async () => {
+      const blob = await createArchive(
+        mockData.name,
+        mockData.model,
+        mockData.template,
+        mockData.data
+      );
+      const file = new File([blob], 'test.cta');
+      const extracted = await extractArchive(file);
+      expect(extracted.name).toBe('Test Template');
+    });
+  });
+
+  describe('round-trip', () => {
+    it('should preserve data through export/import cycle', async () => {
+      const blob = await createArchive(
+        mockData.name,
+        mockData.model,
+        mockData.template,
+        mockData.data
+      );
+      const file = new File([blob], 'roundtrip.cta');
+      const result = await extractArchive(file);
+
+      expect(result.name).toBe(mockData.name);
+      expect(result.model).toBe(mockData.model);
+      expect(result.template).toBe(mockData.template);
+      expect(result.data).toBe(mockData.data);
+    });
+  });
+  describe('error handling', () => {
+    it('should throw when archive is missing model file', async () => {
+      const JSZip = (await import('jszip')).default;
+      const zip = new JSZip();
+      zip.file('package.json', '{"name":"test"}');
+      zip.file('text/grammar.tem.md', 'template');
+      const blob = await zip.generateAsync({ type: 'blob' });
+      const file = new File([blob], 'bad.cta');
+
+      await expect(extractArchive(file)).rejects.toThrow('Archive missing model .cto file');
+    });
+
+    it('should throw when archive is missing grammar file', async () => {
+      const JSZip = (await import('jszip')).default;
+      const zip = new JSZip();
+      zip.file('package.json', '{"name":"test"}');
+      zip.file('model/model.cto', 'namespace test');
+      const blob = await zip.generateAsync({ type: 'blob' });
+      const file = new File([blob], 'bad.cta');
+
+      await expect(extractArchive(file)).rejects.toThrow('Archive missing text/grammar.tem.md');
+    });
+  });
+});