@bernierllc/content-type-audio 1.0.1

package/__tests__/integration.test.ts

@@ -0,0 +1,279 @@
+/*
+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 } from '../src/AudioContentTypeManager';
+import { AudioFormat } from '../src/types';
+import { ContentTypeRegistry } from '@bernierllc/content-type-registry';
+
+describe('Integration Tests', () => {
+  describe('AudioContentTypeManager with ContentTypeRegistry', () => {
+    it('should integrate with content type registry', () => {
+      const registry = new ContentTypeRegistry();
+      const manager = new AudioContentTypeManager();
+
+      manager.register(registry);
+
+      const result = registry.get('audio');
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data?.id).toBe('audio');
+      expect(result.data?.name).toBe('Audio');
+    });
+
+    it('should find registered audio type by filter', () => {
+      const registry = new ContentTypeRegistry();
+      const manager = new AudioContentTypeManager();
+
+      manager.register(registry);
+
+      const result = registry.list({ baseType: 'audio' });
+      expect(result.success).toBe(true);
+      expect(result.data).toBeDefined();
+      expect(result.data).toHaveLength(1);
+      expect(result.data?.[0].id).toBe('audio');
+    });
+
+    it('should validate content using registered schema', () => {
+      const registry = new ContentTypeRegistry();
+      const manager = new AudioContentTypeManager();
+
+      manager.register(registry);
+
+      const content = manager.create({
+        filename: 'test.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 1024 * 1024,
+        duration: 60,
+        bitrate: 128
+      });
+
+      const validation = manager.validate(content);
+      expect(validation.valid).toBe(true);
+    });
+  });
+
+  describe('End-to-end workflow', () => {
+    it('should handle complete audio content lifecycle', async () => {
+      // 1. Create manager
+      const manager = new AudioContentTypeManager({
+        maxFileSize: 10 * 1024 * 1024,
+        allowedFormats: [AudioFormat.MP3, AudioFormat.WAV],
+        requireMetadata: false
+      });
+
+      // 2. Register with registry
+      const registry = new ContentTypeRegistry();
+      manager.register(registry);
+
+      // 3. Create audio content
+      const audioContent = manager.create(
+        {
+          filename: 'podcast-episode.mp3',
+          mimeType: AudioFormat.MP3,
+          size: 5 * 1024 * 1024,
+          duration: 1800, // 30 minutes
+          bitrate: 192,
+          title: 'My Podcast Episode',
+          artist: 'Podcast Host'
+        },
+        {
+          filePath: '/storage/audio/podcast-episode.mp3',
+          streamingUrl: 'https://cdn.example.com/podcast-episode.mp3'
+        }
+      );
+
+      // 4. Validate content
+      const validation = manager.validate(audioContent);
+      expect(validation.valid).toBe(true);
+
+      // 5. Verify content structure
+      expect(audioContent.id).toBeDefined();
+      expect(audioContent.type).toBe('audio');
+      expect(audioContent.metadata.title).toBe('My Podcast Episode');
+      expect(audioContent.filePath).toBe('/storage/audio/podcast-episode.mp3');
+      expect(audioContent.streamingUrl).toBe('https://cdn.example.com/podcast-episode.mp3');
+    });
+
+    it('should handle multiple audio formats', async () => {
+      const manager = new AudioContentTypeManager();
+      const registry = new ContentTypeRegistry();
+      manager.register(registry);
+
+      const formats = [
+        AudioFormat.MP3,
+        AudioFormat.WAV,
+        AudioFormat.AAC,
+        AudioFormat.OGG,
+        AudioFormat.FLAC,
+        AudioFormat.M4A
+      ];
+
+      for (const format of formats) {
+        const content = manager.create({
+          filename: `test.${format.split('/')[1]}`,
+          mimeType: format,
+          size: 1024 * 1024,
+          duration: 60,
+          bitrate: 128
+        });
+
+        const validation = manager.validate(content);
+        expect(validation.valid).toBe(true);
+      }
+    });
+
+    it('should calculate accurate bitrate for real file scenarios', () => {
+      const manager = new AudioContentTypeManager();
+
+      // Scenario 1: MP3 at 128kbps, 3 minutes
+      const mp3Duration = 180; // 3 minutes
+      const mp3Size = Math.round((128 * 1000 * mp3Duration) / 8); // bytes
+      const mp3Bitrate = manager.calculateBitrate(mp3Size, mp3Duration);
+      expect(mp3Bitrate).toBeCloseTo(128, 1);
+
+      // Scenario 2: High quality WAV, 5 minutes
+      const wavDuration = 300; // 5 minutes
+      const wavSize = Math.round((1411 * 1000 * wavDuration) / 8); // CD quality
+      const wavBitrate = manager.calculateBitrate(wavSize, wavDuration);
+      expect(wavBitrate).toBeCloseTo(1411, 1);
+    });
+
+    it('should format and parse durations consistently', () => {
+      const manager = new AudioContentTypeManager();
+
+      const durations = [30, 90, 180, 1800, 3600, 5025];
+
+      for (const duration of durations) {
+        const formatted = manager.formatDuration(duration);
+        const parsed = manager.parseDuration(formatted);
+        expect(parsed).toBe(duration);
+      }
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle validation errors gracefully', async () => {
+      const manager = new AudioContentTypeManager({
+        maxFileSize: 1024 * 1024, // 1MB
+        requireMetadata: true
+      });
+
+      const content = manager.create({
+        filename: 'large.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 10 * 1024 * 1024, // 10MB (exceeds limit)
+        duration: 600,
+        bitrate: 192
+        // Missing title (required)
+      });
+
+      const validation = manager.validate(content);
+
+      expect(validation.valid).toBe(false);
+      expect(validation.errors).toBeDefined();
+      expect(validation.errors?.length).toBeGreaterThan(0);
+    });
+
+    it('should handle multiple validation errors', async () => {
+      const manager = new AudioContentTypeManager({
+        maxFileSize: 1024 * 1024,
+        allowedFormats: [AudioFormat.MP3],
+        requireMetadata: true
+      });
+
+      const content = manager.create({
+        filename: 'test.flac',
+        mimeType: AudioFormat.FLAC, // Not allowed
+        size: 10 * 1024 * 1024, // Too large
+        duration: 600,
+        bitrate: 192
+        // Missing title
+      });
+
+      const validation = manager.validate(content);
+
+      expect(validation.valid).toBe(false);
+      expect(validation.errors).toBeDefined();
+      expect(validation.errors?.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('Configuration scenarios', () => {
+    it('should work with minimal configuration', async () => {
+      const manager = new AudioContentTypeManager();
+      const registry = new ContentTypeRegistry();
+
+      manager.register(registry);
+
+      const content = manager.create({
+        filename: 'test.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 1024 * 1024,
+        duration: 60,
+        bitrate: 128
+      });
+
+      const validation = manager.validate(content);
+      expect(validation.valid).toBe(true);
+    });
+
+    it('should work with restrictive configuration', async () => {
+      const manager = new AudioContentTypeManager({
+        maxFileSize: 512 * 1024, // 512KB
+        allowedFormats: [AudioFormat.MP3],
+        requireMetadata: true
+      });
+
+      // Valid content
+      const validContent = manager.create({
+        filename: 'small.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 256 * 1024,
+        duration: 30,
+        bitrate: 64,
+        title: 'Small Audio'
+      });
+
+      const validation = manager.validate(validContent);
+      expect(validation.valid).toBe(true);
+
+      // Invalid content (too large)
+      const invalidContent = manager.create({
+        filename: 'large.mp3',
+        mimeType: AudioFormat.MP3,
+        size: 1024 * 1024,
+        duration: 120,
+        bitrate: 128,
+        title: 'Large Audio'
+      });
+
+      const invalidValidation = manager.validate(invalidContent);
+      expect(invalidValidation.valid).toBe(false);
+    });
+
+    it('should work with permissive configuration', async () => {
+      const manager = new AudioContentTypeManager({
+        maxFileSize: 500 * 1024 * 1024, // 500MB
+        allowedFormats: Object.values(AudioFormat),
+        requireMetadata: false
+      });
+
+      // Very large file
+      const content = manager.create({
+        filename: 'huge.flac',
+        mimeType: AudioFormat.FLAC,
+        size: 100 * 1024 * 1024,
+        duration: 3600,
+        bitrate: 1411
+      });
+
+      const validation = manager.validate(content);
+      expect(validation.valid).toBe(true);
+    });
+  });
+});

package/__tests__/utils.test.ts

@@ -0,0 +1,142 @@
+/*
+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 {
+  parseDuration,
+  formatDuration,
+  calculateBitrate,
+  generateAudioId
+} from '../src/utils';
+
+describe('Audio Utilities', () => {
+  describe('parseDuration', () => {
+    it('should parse duration from seconds number', () => {
+      expect(parseDuration(123)).toBe(123);
+      expect(parseDuration(0)).toBe(0);
+      expect(parseDuration(3600)).toBe(3600);
+    });
+
+    it('should parse duration from seconds string', () => {
+      expect(parseDuration('123')).toBe(123);
+      expect(parseDuration('0')).toBe(0);
+      expect(parseDuration('3600')).toBe(3600);
+    });
+
+    it('should parse duration from mm:ss format', () => {
+      expect(parseDuration('1:30')).toBe(90); // 1m 30s
+      expect(parseDuration('23:45')).toBe(1425); // 23m 45s
+      expect(parseDuration('0:00')).toBe(0);
+      expect(parseDuration('59:59')).toBe(3599);
+    });
+
+    it('should parse duration from hh:mm:ss format', () => {
+      expect(parseDuration('1:23:45')).toBe(5025); // 1h 23m 45s
+      expect(parseDuration('0:23:45')).toBe(1425); // 23m 45s
+      expect(parseDuration('2:00:00')).toBe(7200); // 2h
+      expect(parseDuration('0:00:00')).toBe(0);
+    });
+
+    it('should handle invalid formats', () => {
+      expect(parseDuration('')).toBe(0);
+      expect(parseDuration('invalid')).toBe(0);
+    });
+  });
+
+  describe('formatDuration', () => {
+    it('should format duration under 1 hour as mm:ss', () => {
+      expect(formatDuration(90)).toBe('1:30');
+      expect(formatDuration(1425)).toBe('23:45');
+      expect(formatDuration(0)).toBe('0:00');
+      expect(formatDuration(59)).toBe('0:59');
+      expect(formatDuration(3599)).toBe('59:59');
+    });
+
+    it('should format duration over 1 hour as hh:mm:ss', () => {
+      expect(formatDuration(5025)).toBe('1:23:45');
+      expect(formatDuration(3600)).toBe('1:00:00');
+      expect(formatDuration(7200)).toBe('2:00:00');
+      expect(formatDuration(86400)).toBe('24:00:00');
+    });
+
+    it('should handle edge cases', () => {
+      expect(formatDuration(0)).toBe('0:00');
+      expect(formatDuration(1)).toBe('0:01');
+      expect(formatDuration(60)).toBe('1:00');
+      expect(formatDuration(3599.9)).toBe('59:59'); // Just under 1 hour
+      expect(formatDuration(3600.1)).toBe('1:00:00'); // Just over 1 hour
+    });
+
+    it('should handle floating point seconds', () => {
+      expect(formatDuration(90.5)).toBe('1:30');
+      expect(formatDuration(59.9)).toBe('0:59');
+    });
+
+    it('should pad single digit values', () => {
+      expect(formatDuration(65)).toBe('1:05');
+      expect(formatDuration(3665)).toBe('1:01:05');
+    });
+  });
+
+  describe('calculateBitrate', () => {
+    it('should calculate bitrate correctly', () => {
+      const fileSize = 5 * 1024 * 1024; // 5MB
+      const duration = 180; // 3 minutes
+
+      const bitrate = calculateBitrate(fileSize, duration);
+
+      expect(bitrate).toBeGreaterThan(0);
+      expect(bitrate).toBeCloseTo(233, 0); // ~233 kbps
+    });
+
+    it('should handle different file sizes and durations', () => {
+      expect(calculateBitrate(1024 * 1024, 60)).toBe(140); // 1MB, 1min = ~140kbps
+      expect(calculateBitrate(10 * 1024 * 1024, 300)).toBe(280); // 10MB, 5min = ~280kbps
+    });
+
+    it('should return 0 for zero duration', () => {
+      expect(calculateBitrate(1024 * 1024, 0)).toBe(0);
+    });
+
+    it('should handle very small files', () => {
+      expect(calculateBitrate(1024, 60)).toBe(0); // Rounds to 0
+    });
+
+    it('should handle very large files', () => {
+      const bitrate = calculateBitrate(100 * 1024 * 1024, 300); // 100MB, 5min
+      expect(bitrate).toBeGreaterThan(0);
+      expect(bitrate).toBeCloseTo(2796, 0);
+    });
+  });
+
+  describe('generateAudioId', () => {
+    it('should generate unique IDs', () => {
+      const id1 = generateAudioId();
+      const id2 = generateAudioId();
+
+      expect(id1).not.toBe(id2);
+    });
+
+    it('should start with audio_ prefix', () => {
+      const id = generateAudioId();
+      expect(id).toMatch(/^audio_/);
+    });
+
+    it('should have correct format', () => {
+      const id = generateAudioId();
+      expect(id).toMatch(/^audio_\d+_[a-z0-9]+$/);
+    });
+
+    it('should generate multiple unique IDs', () => {
+      const ids = new Set();
+      for (let i = 0; i < 100; i++) {
+        ids.add(generateAudioId());
+      }
+      expect(ids.size).toBe(100);
+    });
+  });
+});