@bernierllc/content-type-audio 1.2.1 → 1.4.0

package/__tests__/AudioContentTypeManager.test.ts

@@ -1,592 +0,0 @@
-/*
-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');
-    });
-  });
-});