@etcsec-com/etc-collector 1.4.0

package/tests/unit/services/export/export.service.test.ts

@@ -0,0 +1,241 @@
+/**
+ * Unit Tests for Export Service
+ * Story 1.9: Export Service
+ */
+
+import { ExportService, ExportAuditResult } from '../../../../src/services/export/export.service';
+import { Finding } from '../../../../src/types/finding.types';
+import { SecurityScore } from '../../../../src/services/audit/scoring.service';
+
+describe('ExportService', () => {
+  let exportService: ExportService;
+
+  const mockScore: SecurityScore = {
+    score: 75.5,
+    rating: 'good',
+    weightedPoints: 100,
+    totalUsers: 1000,
+    findings: {
+      critical: 5,
+      high: 10,
+      medium: 0,
+      low: 0,
+      total: 15,
+    },
+    categories: {
+      passwords: 5,
+      kerberos: 0,
+      accounts: 10,
+      groups: 0,
+      computers: 0,
+      advanced: 0,
+      permissions: 0,
+      config: 0,
+      identity: 0,
+      applications: 0,
+      conditionalAccess: 0,
+      privilegedAccess: 0,
+    },
+  };
+
+  const mockFindings: Finding[] = [
+    {
+      type: 'PASSWORD_NOT_REQUIRED',
+      severity: 'critical',
+      category: 'passwords',
+      title: 'Password Not Required',
+      description: 'User account does not require a password',
+      count: 5,
+      affectedEntities: ['user1', 'user2'],
+    },
+    {
+      type: 'USER_INACTIVE',
+      severity: 'high',
+      category: 'accounts',
+      title: 'Inactive User',
+      description: 'User has not logged in for 90+ days',
+      count: 10,
+    },
+  ];
+
+  const mockAuditResult: ExportAuditResult = {
+    score: mockScore,
+    findings: mockFindings,
+    stats: {
+      totalUsers: 1000,
+      totalGroups: 50,
+      totalComputers: 100,
+      totalFindings: 15,
+      executionTimeMs: 5000,
+    },
+    timestamp: new Date('2026-01-12T10:30:00Z'),
+  };
+
+  beforeEach(() => {
+    exportService = new ExportService();
+  });
+
+  describe('exportToJSON', () => {
+    it('should export audit result as JSON', () => {
+      const result = exportService.exportToJSON(mockAuditResult, {
+        provider: 'ad',
+        domain: 'example.com',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content).toBeDefined();
+      expect(result.contentType).toBe('application/json; charset=utf-8');
+      expect(result.contentDisposition).toContain('attachment');
+    });
+
+    it('should produce valid JSON', () => {
+      const result = exportService.exportToJSON(mockAuditResult, {
+        provider: 'ad',
+        domain: 'example.com',
+      });
+
+      expect(() => JSON.parse(result.content)).not.toThrow();
+    });
+
+    it('should include correct Content-Disposition header', () => {
+      const result = exportService.exportToJSON(mockAuditResult, {
+        provider: 'ad',
+        domain: 'EXAMPLE',
+      });
+
+      expect(result.contentDisposition).toContain('filename="audit-ad-EXAMPLE-');
+      expect(result.contentDisposition).toContain('.json"');
+    });
+
+    it('should handle Azure provider', () => {
+      const result = exportService.exportToJSON(mockAuditResult, {
+        provider: 'azure',
+        tenantId: 'tenant-123',
+      });
+
+      const parsed = JSON.parse(result.content);
+      expect(parsed.metadata.provider).toBe('azure');
+      expect(parsed.metadata.tenantId).toBe('tenant-123');
+    });
+
+    it('should exclude affectedEntities by default', () => {
+      const result = exportService.exportToJSON(mockAuditResult, {
+        provider: 'ad',
+        domain: 'example.com',
+      });
+
+      const parsed = JSON.parse(result.content);
+      expect(parsed.findings[0].affectedEntities).toBeUndefined();
+    });
+
+    it('should include affectedEntities when includeDetails=true', () => {
+      const result = exportService.exportToJSON(mockAuditResult, {
+        provider: 'ad',
+        domain: 'example.com',
+        includeDetails: true,
+      });
+
+      const parsed = JSON.parse(result.content);
+      expect(parsed.findings[0].affectedEntities).toBeDefined();
+      expect(parsed.findings[0].affectedEntities).toHaveLength(2);
+    });
+
+    it('should use tenantId as domain fallback', () => {
+      const result = exportService.exportToJSON(mockAuditResult, {
+        provider: 'azure',
+        tenantId: 'tenant-123',
+      });
+
+      expect(result.contentDisposition).toContain('tenant-123');
+    });
+
+    it('should use "unknown" as domain when neither domain nor tenantId provided', () => {
+      const result = exportService.exportToJSON(mockAuditResult, {
+        provider: 'ad',
+      });
+
+      expect(result.contentDisposition).toContain('unknown');
+    });
+  });
+
+  describe('exportToCSV', () => {
+    it('should export audit result as CSV', () => {
+      const result = exportService.exportToCSV(mockAuditResult, 'ad', 'example.com');
+
+      expect(result).toBeDefined();
+      expect(result.content).toBeDefined();
+      expect(result.contentType).toBe('text/csv; charset=utf-8');
+      expect(result.contentDisposition).toContain('attachment');
+    });
+
+    it('should include CSV header row', () => {
+      const result = exportService.exportToCSV(mockAuditResult, 'ad', 'example.com');
+
+      const lines = result.content.split('\n');
+      const header = lines[0]?.replace('\uFEFF', '');
+
+      expect(header).toBe('Category,Type,Severity,Count,Title,Description');
+    });
+
+    it('should include all findings as data rows', () => {
+      const result = exportService.exportToCSV(mockAuditResult, 'ad', 'example.com');
+
+      const lines = result.content.split('\n');
+      expect(lines.length).toBe(3); // 1 header + 2 data rows
+    });
+
+    it('should include UTF-8 BOM', () => {
+      const result = exportService.exportToCSV(mockAuditResult, 'ad', 'example.com');
+
+      expect(result.content.charCodeAt(0)).toBe(0xfeff);
+    });
+
+    it('should include correct Content-Disposition header', () => {
+      const result = exportService.exportToCSV(mockAuditResult, 'ad', 'EXAMPLE');
+
+      expect(result.contentDisposition).toContain('filename="audit-ad-EXAMPLE-');
+      expect(result.contentDisposition).toContain('.csv"');
+    });
+
+    it('should include Affected Objects column when option enabled', () => {
+      const result = exportService.exportToCSV(mockAuditResult, 'ad', 'example.com', {
+        includeAffectedEntities: true,
+      });
+
+      const lines = result.content.split('\n');
+      const header = lines[0]?.replace('\uFEFF', '');
+
+      expect(header).toContain('Affected Objects');
+    });
+
+    it('should use custom delimiter when provided', () => {
+      const result = exportService.exportToCSV(mockAuditResult, 'ad', 'example.com', {
+        delimiter: ';',
+      });
+
+      const lines = result.content.split('\n');
+      const header = lines[0]?.replace('\uFEFF', '');
+
+      expect(header).toContain(';');
+      expect(header).not.toContain(',');
+    });
+
+    it('should handle Azure provider', () => {
+      const result = exportService.exportToCSV(mockAuditResult, 'azure', 'tenant-123');
+
+      expect(result.contentDisposition).toContain('audit-azure-tenant-123-');
+    });
+
+    it('should handle empty findings array', () => {
+      const emptyAuditResult: ExportAuditResult = {
+        ...mockAuditResult,
+        findings: [],
+      };
+
+      const result = exportService.exportToCSV(emptyAuditResult, 'ad', 'example.com');
+
+      const lines = result.content.split('\n');
+      expect(lines.length).toBe(1); // Only header
+    });
+  });
+});

package/tests/unit/services/export/formatters/csv.formatter.test.ts

@@ -0,0 +1,270 @@
+/**
+ * Unit Tests for CSV Formatter
+ * Story 1.9: Export Service
+ */
+
+import {
+  formatAsCSV,
+  getCSVContentDisposition,
+  CSVExportOptions,
+} from '../../../../../src/services/export/formatters/csv.formatter';
+import { Finding } from '../../../../../src/types/finding.types';
+
+describe('CSV Formatter', () => {
+  const mockFindings: Finding[] = [
+    {
+      type: 'PASSWORD_NOT_REQUIRED',
+      severity: 'critical',
+      category: 'passwords',
+      title: 'Password Not Required',
+      description: 'User account does not require a password',
+      count: 5,
+      affectedEntities: ['user1', 'user2', 'user3'],
+    },
+    {
+      type: 'USER_INACTIVE',
+      severity: 'high',
+      category: 'accounts',
+      title: 'Inactive User',
+      description: 'User has not logged in for 90+ days',
+      count: 10,
+    },
+    {
+      type: 'PASSWORD_OLD',
+      severity: 'medium',
+      category: 'passwords',
+      title: 'Old Password',
+      description: 'Password not changed for 180+ days',
+      count: 20,
+      affectedEntities: ['olduser1'],
+    },
+  ];
+
+  describe('formatAsCSV', () => {
+    it('should format findings as CSV with header row', () => {
+      const result = formatAsCSV(mockFindings);
+
+      const lines = result.split('\n');
+      expect(lines.length).toBeGreaterThan(1);
+
+      // Check header (skip BOM)
+      const header = lines[0]?.replace('\uFEFF', '') || '';
+      expect(header).toBe('Category,Type,Severity,Count,Title,Description');
+    });
+
+    it('should include all findings as data rows', () => {
+      const result = formatAsCSV(mockFindings);
+
+      const lines = result.split('\n');
+      expect(lines.length).toBe(4); // 1 header + 3 data rows
+    });
+
+    it('should format data row correctly', () => {
+      const result = formatAsCSV(mockFindings);
+
+      const lines = result.split('\n');
+      const firstDataRow = lines[1];
+
+      expect(firstDataRow).toContain('passwords');
+      expect(firstDataRow).toContain('PASSWORD_NOT_REQUIRED');
+      expect(firstDataRow).toContain('critical');
+      expect(firstDataRow).toContain('5');
+      expect(firstDataRow).toContain('Password Not Required');
+    });
+
+    it('should escape values containing commas', () => {
+      const findings: Finding[] = [
+        {
+          type: 'TEST',
+          severity: 'low',
+          category: 'passwords',
+          title: 'Test, with comma',
+          description: 'Description, also with comma',
+          count: 1,
+        },
+      ];
+
+      const result = formatAsCSV(findings);
+
+      expect(result).toContain('"Test, with comma"');
+      expect(result).toContain('"Description, also with comma"');
+    });
+
+    it('should escape values containing double quotes', () => {
+      const findings: Finding[] = [
+        {
+          type: 'TEST',
+          severity: 'low',
+          category: 'passwords',
+          title: 'Test with "quotes"',
+          description: 'Description with "quotes"',
+          count: 1,
+        },
+      ];
+
+      const result = formatAsCSV(findings);
+
+      // Double quotes should be escaped as ""
+      expect(result).toContain('"Test with ""quotes"""');
+      expect(result).toContain('"Description with ""quotes"""');
+    });
+
+    it('should escape values containing newlines', () => {
+      const findings: Finding[] = [
+        {
+          type: 'TEST',
+          severity: 'low',
+          category: 'passwords',
+          title: 'Test\nwith newline',
+          description: 'Description\nwith newline',
+          count: 1,
+        },
+      ];
+
+      const result = formatAsCSV(findings);
+
+      expect(result).toContain('"Test\nwith newline"');
+      expect(result).toContain('"Description\nwith newline"');
+    });
+
+    it('should not escape simple values', () => {
+      const findings: Finding[] = [
+        {
+          type: 'SIMPLE_TEST',
+          severity: 'low',
+          category: 'passwords',
+          title: 'Simple Title',
+          description: 'Simple description without special characters',
+          count: 1,
+        },
+      ];
+
+      const result = formatAsCSV(findings);
+
+      const lines = result.split('\n');
+      const dataRow = lines[1];
+
+      // Simple values should NOT be wrapped in quotes
+      expect(dataRow).toContain('Simple Title');
+      expect(dataRow).not.toContain('"Simple Title"');
+    });
+
+    it('should include UTF-8 BOM for Excel compatibility', () => {
+      const result = formatAsCSV(mockFindings);
+
+      // Check for BOM character at start
+      expect(result.charCodeAt(0)).toBe(0xfeff);
+    });
+
+    it('should include Affected Objects column when includeAffectedEntities=true', () => {
+      const options: CSVExportOptions = {
+        includeAffectedEntities: true,
+      };
+
+      const result = formatAsCSV(mockFindings, options);
+
+      const lines = result.split('\n');
+      const header = lines[0]?.replace('\uFEFF', '');
+
+      expect(header).toBe('Category,Type,Severity,Count,Title,Description,Affected Objects');
+    });
+
+    it('should include affected entities in data rows when enabled', () => {
+      const options: CSVExportOptions = {
+        includeAffectedEntities: true,
+      };
+
+      const result = formatAsCSV(mockFindings, options);
+
+      const lines = result.split('\n');
+      const firstDataRow = lines[1];
+
+      // Should contain semicolon-separated list
+      expect(firstDataRow).toContain('user1; user2; user3');
+    });
+
+    it('should handle missing affectedEntities gracefully', () => {
+      const options: CSVExportOptions = {
+        includeAffectedEntities: true,
+      };
+
+      const result = formatAsCSV(mockFindings, options);
+
+      const lines = result.split('\n');
+      const secondDataRow = lines[2] || '';
+
+      // USER_INACTIVE has no affectedEntities
+      expect(secondDataRow.split(',').length).toBe(7); // All 7 columns present
+    });
+
+    it('should use custom delimiter when provided', () => {
+      const options: CSVExportOptions = {
+        delimiter: ';',
+      };
+
+      const result = formatAsCSV(mockFindings, options);
+
+      const lines = result.split('\n');
+      const header = lines[0]?.replace('\uFEFF', '');
+
+      expect(header).toBe('Category;Type;Severity;Count;Title;Description');
+    });
+
+    it('should handle empty findings array', () => {
+      const result = formatAsCSV([]);
+
+      const lines = result.split('\n');
+      expect(lines.length).toBe(1); // Only header
+    });
+
+    it('should handle findings with empty descriptions', () => {
+      const findings: Finding[] = [
+        {
+          type: 'TEST',
+          severity: 'low',
+          category: 'passwords',
+          title: 'Test',
+          description: '',
+          count: 1,
+        },
+      ];
+
+      const result = formatAsCSV(findings);
+
+      expect(() => result.split('\n')).not.toThrow();
+      expect(result.split('\n').length).toBe(2); // Header + 1 data row
+    });
+  });
+
+  describe('getCSVContentDisposition', () => {
+    it('should generate correct Content-Disposition header', () => {
+      const result = getCSVContentDisposition('ad', 'EXAMPLE');
+
+      expect(result).toContain('attachment');
+      expect(result).toContain('filename="audit-ad-EXAMPLE-');
+      expect(result).toContain('.csv"');
+    });
+
+    it('should sanitize domain name', () => {
+      const result = getCSVContentDisposition('ad', 'example.local@test');
+
+      // Domain should be sanitized (no dots or @)
+      expect(result).toContain('audit-ad-example-local-test-');
+      // Should not contain the original domain with dots/@ (but .csv extension is ok)
+      expect(result).not.toContain('example.local@test');
+    });
+
+    it('should include timestamp in ISO format', () => {
+      const result = getCSVContentDisposition('ad', 'EXAMPLE');
+
+      // Should contain timestamp like 2026-01-12T10-30-00Z
+      expect(result).toMatch(/\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}Z\.csv"/);
+    });
+
+    it('should work with Azure provider', () => {
+      const result = getCSVContentDisposition('azure', 'tenant-123');
+
+      expect(result).toContain('audit-azure-tenant-123-');
+    });
+  });
+});