@bernierllc/content-type-audio 1.0.1

package/__tests__/AudioContentTypeManager.test.ts

@@ -0,0 +1,592 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { AudioContentTypeManager, validateAudio } from '../src/AudioContentTypeManager';
+import { AudioFormat, AudioContentType, AudioMetadata } from '../src/types';
+import { ContentTypeRegistry } from '@bernierllc/content-type-registry';
+
+describe('AudioContentTypeManager', () => {
+  let manager: AudioContentTypeManager;
+
+  beforeEach(() => {
+    manager = new AudioContentTypeManager({
+      maxFileSize: 50 * 1024 * 1024, // 50MB
+      allowedFormats: [AudioFormat.MP3, AudioFormat.WAV],
+      requireMetadata: true
+    });
+  });
+
+  describe('constructor', () => {
+    it('should create manager with default config', () => {
+      const defaultManager = new AudioContentTypeManager();
+      expect(defaultManager).toBeDefined();
+    });
+
+    it('should create manager with custom config', () => {
+      const customManager = new AudioContentTypeManager({
+        maxFileSize: 10 * 1024 * 1024,
+        allowedFormats: [AudioFormat.MP3],
+        requireMetadata: false
+      });
+      expect(customManager).toBeDefined();
+    });
+
+    it('should merge custom config with defaults', () => {
+      const partialManager = new AudioContentTypeManager({
+        maxFileSize: 20 * 1024 * 1024
+      });
+      expect(partialManager).toBeDefined();
+    });
+  });
+
+  describe('register', () => {
+    it('should register audio content type with registry', () => {
+      const registry = new ContentTypeRegistry();
+      manager.register(registry);
+
+      const result = registry.get('audio');
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data?.name).toBe('Audio');
+      expect(result.data?.baseType).toBe('audio');
+    });
+
+    it('should include editor configuration', () => {
+      const registry = new ContentTypeRegistry();
+      manager.register(registry);
+
+      const result = registry.get('audio');
+      expect(result.success).toBe(true);
+      expect(result.data?.editor).toBeDefined();
+      expect(result.data?.editor.component).toBe('file-upload-with-player');
+    });
+
+    it('should include storage and publishing configuration', () => {
+      const registry = new ContentTypeRegistry();
+      manager.register(registry);
+
+      const result = registry.get('audio');
+      expect(result.success).toBe(true);
+      expect(result.data?.storage).toBeDefined();
+      expect(result.data?.publishing).toBeDefined();
+    });
+  });
+
+  describe('getSchema', () => {
+    it('should return Zod schema', () => {
+      const schema = manager.getSchema();
+      expect(schema).toBeDefined();
+    });
+  });
+
+  describe('validate', () => {
+    it('should validate correct audio content', async () => {
+      const content: AudioContentType = {
+        id: 'audio_123',
+        type: 'audio',
+        metadata: {
+          filename: 'song.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 5 * 1024 * 1024, // 5MB
+          duration: 180, // 3 minutes
+          bitrate: 192,
+          title: 'Test Song'
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toBeUndefined();
+      expect(result.metadata?.title).toBe('Test Song');
+    });
+
+    it('should reject audio exceeding max file size', async () => {
+      const content: AudioContentType = {
+        id: 'audio_456',
+        type: 'audio',
+        metadata: {
+          filename: 'large.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 100 * 1024 * 1024, // 100MB (exceeds 50MB limit)
+          duration: 3600,
+          bitrate: 192,
+          title: 'Large File'
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+      expect(result.errors?.[0]).toContain('exceeds maximum');
+    });
+
+    it('should reject disallowed audio formats', async () => {
+      const content: AudioContentType = {
+        id: 'audio_789',
+        type: 'audio',
+        metadata: {
+          filename: 'song.flac',
+          mimeType: AudioFormat.FLAC, // Not in allowedFormats
+          size: 1024 * 1024,
+          duration: 60,
+          bitrate: 128,
+          title: 'Test Song'
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+      expect(result.errors?.[0]).toContain('not allowed');
+    });
+
+    it('should require title when requireMetadata is true', async () => {
+      const content: AudioContentType = {
+        id: 'audio_101',
+        type: 'audio',
+        metadata: {
+          filename: 'song.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 1024 * 1024,
+          duration: 60,
+          bitrate: 128
+          // No title
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+      expect(result.errors?.[0]).toContain('Title is required');
+    });
+
+    it('should handle invalid content structure', async () => {
+      const invalidContent = {
+        id: 'audio_999',
+        type: 'video', // Wrong type
+        metadata: {}
+      };
+
+      const result = manager.validate(invalidContent);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+    });
+
+    it('should handle missing required fields', async () => {
+      const incompleteContent = {
+        id: 'audio_888',
+        type: 'audio'
+        // Missing metadata
+      };
+
+      const result = manager.validate(incompleteContent);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+    });
+
+    it('should validate optional fields', async () => {
+      const content: AudioContentType = {
+        id: 'audio_777',
+        type: 'audio',
+        metadata: {
+          filename: 'song.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 1024 * 1024,
+          duration: 60,
+          bitrate: 128,
+          title: 'Test Song',
+          artist: 'Test Artist',
+          album: 'Test Album',
+          year: 2024,
+          sampleRate: 44100,
+          channels: 2
+        },
+        filePath: '/path/to/song.mp3',
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+
+      expect(result.valid).toBe(true);
+      expect(result.metadata?.artist).toBe('Test Artist');
+      expect(result.metadata?.album).toBe('Test Album');
+      expect(result.metadata?.year).toBe(2024);
+    });
+
+    it('should reject negative duration', async () => {
+      const content: AudioContentType = {
+        id: 'audio_666',
+        type: 'audio',
+        metadata: {
+          filename: 'song.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 1024 * 1024,
+          duration: -10, // Invalid
+          bitrate: 128,
+          title: 'Test Song'
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+    });
+
+    it('should reject negative bitrate', async () => {
+      const content: AudioContentType = {
+        id: 'audio_555',
+        type: 'audio',
+        metadata: {
+          filename: 'song.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 1024 * 1024,
+          duration: 60,
+          bitrate: -128, // Invalid
+          title: 'Test Song'
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+    });
+
+    it('should reject invalid year range', () => {
+      const content: AudioContentType = {
+        id: 'audio_444',
+        type: 'audio',
+        metadata: {
+          filename: 'song.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 1024 * 1024,
+          duration: 60,
+          bitrate: 128,
+          title: 'Test Song',
+          year: 3000 // Too far in future
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+    });
+
+    it('should handle validation with allowed formats config', () => {
+      const manager = new AudioContentTypeManager({
+        allowedFormats: [AudioFormat.MP3, AudioFormat.WAV]
+      });
+
+      const content: AudioContentType = {
+        id: 'audio_333',
+        type: 'audio',
+        metadata: {
+          filename: 'song.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 1024 * 1024,
+          duration: 60,
+          bitrate: 128
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+      expect(result.valid).toBe(true);
+    });
+
+    it('should handle validation without maxFileSize config', () => {
+      const manager = new AudioContentTypeManager({
+        maxFileSize: undefined
+      });
+
+      const content: AudioContentType = {
+        id: 'audio_222',
+        type: 'audio',
+        metadata: {
+          filename: 'huge.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 500 * 1024 * 1024, // 500MB
+          duration: 3600,
+          bitrate: 320
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+      expect(result.valid).toBe(true);
+    });
+
+    it('should handle validation without allowedFormats config', () => {
+      const manager = new AudioContentTypeManager({
+        allowedFormats: undefined
+      });
+
+      const content: AudioContentType = {
+        id: 'audio_111',
+        type: 'audio',
+        metadata: {
+          filename: 'song.flac',
+          mimeType: AudioFormat.FLAC,
+          size: 1024 * 1024,
+          duration: 60,
+          bitrate: 1411
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = manager.validate(content);
+      expect(result.valid).toBe(true);
+    });
+
+    it('should handle validation catching non-Zod errors', () => {
+      const manager = new AudioContentTypeManager();
+
+      // Trigger an error by passing something that causes a non-ZodError
+      const result = manager.validate(undefined);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toBeDefined();
+    });
+  });
+
+  describe('create', () => {
+    it('should create audio content with metadata', () => {
+      const metadata: AudioMetadata = {
+        filename: 'test.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 1024 * 1024,
+        duration: 60,
+        bitrate: 128,
+        title: 'Test Audio'
+      };
+
+      const content = manager.create(metadata, {
+        filePath: '/path/to/test.mp3',
+        streamingUrl: 'https://cdn.example.com/test.mp3'
+      });
+
+      expect(content.type).toBe('audio');
+      expect(content.metadata.title).toBe('Test Audio');
+      expect(content.filePath).toBe('/path/to/test.mp3');
+      expect(content.streamingUrl).toBe('https://cdn.example.com/test.mp3');
+      expect(content.id).toMatch(/^audio_/);
+      expect(content.createdAt).toBeInstanceOf(Date);
+      expect(content.updatedAt).toBeInstanceOf(Date);
+    });
+
+    it('should create audio content without optional fields', () => {
+      const metadata: AudioMetadata = {
+        filename: 'test.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 1024 * 1024,
+        duration: 60,
+        bitrate: 128
+      };
+
+      const content = manager.create(metadata);
+
+      expect(content.type).toBe('audio');
+      expect(content.filePath).toBeUndefined();
+      expect(content.fileUrl).toBeUndefined();
+      expect(content.streamingUrl).toBeUndefined();
+    });
+
+    it('should generate unique IDs', () => {
+      const metadata: AudioMetadata = {
+        filename: 'test.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 1024 * 1024,
+        duration: 60,
+        bitrate: 128
+      };
+
+      const content1 = manager.create(metadata);
+      const content2 = manager.create(metadata);
+
+      expect(content1.id).not.toBe(content2.id);
+    });
+  });
+
+  describe('utility methods', () => {
+    it('should parse duration', () => {
+      expect(manager.parseDuration('1:23:45')).toBe(5025);
+      expect(manager.parseDuration('23:45')).toBe(1425);
+      expect(manager.parseDuration('123')).toBe(123);
+      expect(manager.parseDuration(180)).toBe(180);
+    });
+
+    it('should format duration', () => {
+      expect(manager.formatDuration(5025)).toBe('1:23:45');
+      expect(manager.formatDuration(1425)).toBe('23:45');
+      expect(manager.formatDuration(45)).toBe('0:45');
+    });
+
+    it('should calculate bitrate', () => {
+      const fileSize = 5 * 1024 * 1024;
+      const duration = 180;
+      const bitrate = manager.calculateBitrate(fileSize, duration);
+
+      expect(bitrate).toBeGreaterThan(0);
+      expect(bitrate).toBeCloseTo(233, 0);
+    });
+  });
+
+  describe('validateAudio wrapper', () => {
+    it('should return success result for valid content', () => {
+      const content: AudioContentType = {
+        id: 'audio_123',
+        type: 'audio',
+        metadata: {
+          filename: 'song.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 5 * 1024 * 1024,
+          duration: 180,
+          bitrate: 192,
+          title: 'Test Song'
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+      };
+
+      const result = validateAudio(manager, content);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data?.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should return error result for invalid content with error message', () => {
+      const invalidContent = {
+        id: 'audio_999',
+        type: 'invalid'
+      };
+
+      const result = validateAudio(manager, invalidContent);
+
+      expect(result.success).toBe(false);
+      expect(result.data).toBeDefined();
+      expect(result.data?.valid).toBe(false);
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain('type');
+    });
+
+    it('should return error result for content with validation errors but no error array', () => {
+      const strictManager = new AudioContentTypeManager({
+        maxFileSize: 1024,
+        requireMetadata: true
+      });
+
+      const content = strictManager.create({
+        filename: 'test.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 2048, // Exceeds limit
+        duration: 60,
+        bitrate: 128
+        // Missing title
+      });
+
+      const result = validateAudio(strictManager, content);
+
+      expect(result.success).toBe(false);
+      expect(result.data).toBeDefined();
+      expect(result.data?.valid).toBe(false);
+    });
+
+    it('should handle exceptions gracefully', () => {
+      const result = validateAudio(manager, null);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty strings in parseDuration', () => {
+      expect(manager.parseDuration('')).toBe(0);
+    });
+
+    it('should handle zero bitrate calculation', () => {
+      expect(manager.calculateBitrate(1024, 0)).toBe(0);
+    });
+
+    it('should format zero duration', () => {
+      expect(manager.formatDuration(0)).toBe('0:00');
+    });
+
+    it('should validate content with no optional URLs', () => {
+      const manager = new AudioContentTypeManager();
+      const content = manager.create({
+        filename: 'test.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 1024 * 1024,
+        duration: 60,
+        bitrate: 128
+      });
+
+      expect(content.filePath).toBeUndefined();
+      expect(content.fileUrl).toBeUndefined();
+      expect(content.streamingUrl).toBeUndefined();
+    });
+
+    it('should validate content with all optional fields', () => {
+      const manager = new AudioContentTypeManager();
+      const content = manager.create(
+        {
+          filename: 'test.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 1024 * 1024,
+          duration: 60,
+          bitrate: 128,
+          sampleRate: 44100,
+          channels: 2,
+          title: 'Test',
+          artist: 'Artist',
+          album: 'Album',
+          year: 2024,
+          coverArt: 'https://example.com/cover.jpg'
+        },
+        {
+          filePath: '/path/to/file',
+          fileUrl: 'https://example.com/file',
+          streamingUrl: 'https://stream.example.com/file'
+        }
+      );
+
+      expect(content.filePath).toBe('/path/to/file');
+      expect(content.fileUrl).toBe('https://example.com/file');
+      expect(content.streamingUrl).toBe('https://stream.example.com/file');
+    });
+  });
+});