added source unit tests

Author: k9p5

src/sources/audio.spec.ts

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) 2024 The Diffusion Studio Authors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla 
+ * Public License, v. 2.0 that can be found in the LICENSE file.
+ */
+
+import { describe, it, vi, beforeEach, expect } from 'vitest';
+import { AudioSource } from './audio'; // Import the AudioSource class
+
+// Mocking the OfflineAudioContext class
+class MockOfflineAudioContext {
+	constructor(public numberOfChannels: number, public length: number, public sampleRate: number) { }
+
+	decodeAudioData(arrayBuffer: ArrayBuffer): Promise<AudioBuffer> {
+		const audioBuffer = {
+			duration: 5, // Mock duration
+			sampleRate: this.sampleRate,
+			getChannelData: () => new Float32Array(5000), // Return a dummy Float32Array
+		} as any as AudioBuffer;
+		return Promise.resolve(audioBuffer);
+	}
+}
+
+vi.stubGlobal('OfflineAudioContext', MockOfflineAudioContext); // Stub the global OfflineAudioContext
+
+describe('AudioSource', () => {
+	let audioSource: AudioSource;
+
+	beforeEach(() => {
+		audioSource = new AudioSource();
+		audioSource.file = new File([], 'audio.mp3', { type: 'audio/mp3' });
+	});
+
+	it('should decode an audio buffer correctly', async () => {
+		const buffer = await audioSource.decode(2, 44100);
+		expect(buffer.duration).toBe(5); // Mock duration
+		expect(buffer.sampleRate).toBe(44100);
+		expect(audioSource.audioBuffer).toBe(buffer);
+		expect(audioSource.duration.seconds).toBe(5); // Ensure duration is set
+	});
+
+	it('should create a thumbnail with correct DOM elements', async () => {
+		const thumbnail = await audioSource.thumbnail(60, 50, 0);
+
+		// Check if the thumbnail is a div
+		expect(thumbnail.tagName).toBe('DIV');
+		expect(thumbnail.className).toContain('audio-samples');
+
+		// Check if it has the right number of children
+		expect(thumbnail.children.length).toBe(60);
+
+		// Check if each child has the correct class
+		for (const child of thumbnail.children) {
+			expect(child.className).toContain('audio-sample-item');
+		}
+	});
+});

src/sources/html.spec.ts

@@ -7,6 +7,8 @@
 
 import { describe, expect, it, vi } from 'vitest';
 import { HtmlSource } from './html';
+import { setFetchMockReturnValue } from '../../vitest.mocks';
+import { sleep } from '../utils';
 
 describe('The Html Source Object', () => {
 	it('should create an object url when the iframe loads', async () => {
@@ -43,6 +45,52 @@ describe('The Html Source Object', () => {
 		await expect(() => source.from(file)).rejects.toThrowError();
 		expect(evtMock).toHaveBeenCalledTimes(1);
 	});
+
+	it('should have a valid document getter', async () => {
+		const source = new HtmlSource();
+
+		expect(source.document).toBeTruthy();
+	});
+
+	it('should create an object url after the fetch has been completed', async () => {
+		const resetFetch = setFetchMockReturnValue({
+			ok: true,
+			blob: async () => {
+				await sleep(10);
+				return new Blob([], { type: 'text/html' });
+			},
+		});
+
+		const source = new HtmlSource();
+
+		mockIframeValid(source);
+
+		source.from('https://external.html');
+
+		expect(source.objectURL).toBeUndefined();
+
+		const url = await source.createObjectURL();
+
+		expect(url).toBe("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg'%3E%3C/svg%3E");
+
+		expect(source.objectURL).toBeDefined();
+
+		resetFetch();
+	});
+
+	it('should retrun a video as thumbnail', async () => {
+		const file = new File([], 'test.html', { type: 'text/html' });
+		const source = new HtmlSource();
+
+		mockIframeValid(source);
+		mockDocumentValid(source);
+
+		await source.from(file);
+
+		const thumbnail = await source.thumbnail();
+
+		expect(thumbnail).toBeInstanceOf(Image);
+	});
 });
 
 function mockIframeValid(source: HtmlSource) {

src/sources/html.utils.spec.ts

@@ -0,0 +1,117 @@
+/**
+ * Copyright (c) 2024 The Diffusion Studio Authors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla 
+ * Public License, v. 2.0 that can be found in the LICENSE file.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { documentToSvgImageUrl, fontToBas64Url } from './html.utils';
+import { setFetchMockReturnValue } from '../../vitest.mocks';
+
+describe('documentToSvgImageUrl', () => {
+	it('should return empty SVG if document is not provided', () => {
+		const result = documentToSvgImageUrl();
+		expect(result).toBe("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg'%3E%3C/svg%3E");
+	});
+
+	it('should return empty SVG if document has no body', () => {
+		const mockDocument = document.implementation.createDocument('', '', null);
+		const result = documentToSvgImageUrl(mockDocument);
+		expect(result).toBe("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg'%3E%3C/svg%3E");
+	});
+
+	it('should return valid SVG when document has body and style', () => {
+		const mockDocument = document.implementation.createHTMLDocument('Test Document');
+		const body = mockDocument.body;
+		const style = mockDocument.createElement('style');
+		style.textContent = 'body { background: red; }';
+		mockDocument.head.appendChild(style);
+		body.innerHTML = '<div>Hello World</div>';
+
+		const result = documentToSvgImageUrl(mockDocument);
+
+		// Check if result starts with valid data URI and contains parts of the body and style
+		expect(result).toContain('data:image/svg+xml;base64,');
+		const decodedSvg = atob(result.split(',')[1]);
+		expect(decodedSvg).toContain('Hello World');
+		expect(decodedSvg).toContain('body { background: red; }');
+	});
+
+	it('should return valid SVG when document has body but no style', () => {
+		const mockDocument = document.implementation.createHTMLDocument('Test Document');
+		const body = mockDocument.body;
+		body.innerHTML = '<div>Hello World</div>';
+
+		const result = documentToSvgImageUrl(mockDocument);
+
+		// Check if result starts with valid data URI and contains parts of the body
+		expect(result).toContain('data:image/svg+xml;base64,');
+		const decodedSvg = atob(result.split(',')[1]);
+		expect(decodedSvg).toContain('Hello World');
+		expect(decodedSvg).not.toContain('<style>'); // There should be no style element
+	});
+
+	it('should handle documents with nested elements', () => {
+		const mockDocument = document.implementation.createHTMLDocument('Test Document');
+		const body = mockDocument.body;
+		body.innerHTML = '<div><p>Nested</p></div>';
+
+		const result = documentToSvgImageUrl(mockDocument);
+
+		// Check if result starts with valid data URI and contains nested elements
+		expect(result).toContain('data:image/svg+xml;base64,');
+		const decodedSvg = atob(result.split(',')[1]);
+		expect(decodedSvg).toContain('<div><p>Nested</p></div>');
+	});
+});
+
+describe('fontToBas64Url', () => {
+	it('should return base64 font URL with format woff2 by default', async () => {
+		// Mock the response from fetch to return a Blob
+		const resetFetch = setFetchMockReturnValue({
+			ok: true,
+			blob: async () => new Blob(['font-data'], { type: 'font/woff2' }),
+		});
+
+		// Mock FileReader and its behavior
+		vi.stubGlobal('FileReader', class {
+			readAsDataURL = vi.fn();
+			set onloadend(fn: () => void) {
+				fn();
+			}
+			result = 'data:font/woff2;base64,Zm9udC1kYXRh';
+		});
+
+		const result = await fontToBas64Url('https://example.com/font.woff2');
+
+		expect(result).toBe(`url(data:font/woff2;base64,Zm9udC1kYXRh) format('woff2')`);
+
+		resetFetch()
+		vi.unstubAllGlobals(); // Cleanup
+	});
+
+	it('should return base64 font URL with format ttf', async () => {
+		// Mock the response from fetch to return a Blob
+		const resetFetch = setFetchMockReturnValue({
+			ok: true,
+			blob: async () => new Blob(['font-data'], { type: 'font/ttf' }),
+		});
+
+		// Mock FileReader and its behavior
+		vi.stubGlobal('FileReader', class {
+			readAsDataURL = vi.fn();
+			set onloadend(fn: () => void) {
+				fn();
+			}
+			result = 'data:font/ttf;base64,Zm9udC1kYXRh';
+		});
+
+		const result = await fontToBas64Url('https://example.com/font.ttf');
+
+		expect(result).toBe(`url(data:font/ttf;base64,Zm9udC1kYXRh) format('truetype')`);
+
+		resetFetch()
+		vi.unstubAllGlobals(); // Cleanup
+	});
+});

src/sources/html.utils.ts

@@ -19,7 +19,8 @@ export function utf8ToBase64(str: string) {
 }
 
 export function documentToSvgImageUrl(doc?: Document) {
-	if (!doc) return emptySvg;
+	if (!doc || !doc.body) return emptySvg;
+	
 	const width = doc.body.scrollWidth;
 	const height = doc.body.scrollHeight;
 

src/sources/image.spec.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2024 The Diffusion Studio Authors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla 
+ * Public License, v. 2.0 that can be found in the LICENSE file.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { ImageSource } from './image';
+
+describe('The Image Source Object', () => {
+	it('should retrun a video as thumbnail', async () => {
+		const file = new File([], 'file.png', { type: 'image/png' });
+		const source = new ImageSource();
+
+		await source.from(file);
+
+		const thumbnail = await source.thumbnail();
+
+		expect(thumbnail).toBeInstanceOf(Image);
+	});
+});

src/sources/source.spec.ts

@@ -8,6 +8,7 @@
 import { setFetchMockReturnValue } from '../../vitest.mocks';
 import { describe, expect, it, vi } from 'vitest';
 import { Source } from './source';
+import { sleep } from '../utils';
 
 describe('The Source Object', () => {
 	it('should be createable from a file', async () => {
@@ -63,6 +64,14 @@ describe('The Source Object', () => {
 		resetFetch();
 	});
 
+	it('should not load from a http address when the response in not ok', async () => {
+		const resetFetch = setFetchMockReturnValue({ ok: false });
+
+		await expect(() => new Source().from('https://external.url')).rejects.toThrowError();
+
+		resetFetch();
+	});
+
 	it('should get a file after the asset has been fetched', async () => {
 		const file = new File([], 'file.mp4', { type: 'video/mp4' });
 
@@ -73,11 +82,47 @@ describe('The Source Object', () => {
 		expect((await source.getFile()).name).toBe('file.mp4');
 	});
 
+	it('should extract the array buffer or the file', async () => {
+		const file = new File([], 'file.mp4', { type: 'video/mp4' });
+
+		const source = new Source();
+		await source.from(file);
+		
+		const buffer = await source.arrayBuffer();
+
+		expect(buffer).toBeInstanceOf(ArrayBuffer);
+	});
+
+	it('should download the file', async () => {
+		const a = document.createElement('a');
+	
+		const clickSpy = vi.spyOn(a, 'click');
+		const createSpy = vi.spyOn(document, 'createElement').mockImplementation(() => a);
+
+		const file = new File([], 'file.mp4', { type: 'video/mp4' });
+
+		const source = new Source();
+		await source.from(file);
+		await source.download();
+
+		expect(clickSpy).toHaveBeenCalledTimes(1);
+		expect(createSpy).toHaveBeenCalledTimes(1);
+		expect(a.download).toBe('file.mp4');
+		createSpy.mockRestore();
+	});
+
 	it('should not get the file if no asset has been added yet', async () => {
 		const source = new Source();
 		await expect(() => source.getFile()).rejects.toThrowError();
 	});
 
+	it('should return an html element as thumbnail', async () => {
+		const source = new Source();
+		const el = await source.thumbnail();
+		
+		expect(el).toBeInstanceOf(HTMLDivElement);
+	});
+
 	it('should create a object url', async () => {
 		const file = new File([], 'file.mp4', { type: 'video/mp4' });
 
@@ -105,4 +150,34 @@ describe('The Source Object', () => {
 		expect(source.file).toBeUndefined();
 		expect(source.objectURL).toBeUndefined();
 	});
+
+	it('should get a file after the fetch has been completed', async () => {
+		const resetFetch = setFetchMockReturnValue({
+			ok: true,
+			blob: async () => {
+				await sleep(10);
+				return new Blob([], { type: 'video/mp4' });
+			},
+		});
+
+		const source = new Source();
+
+		source.from('https://external.url');
+
+		expect(source.file).toBeUndefined();
+
+		const file = await source.getFile();
+
+		expect(file).toBeInstanceOf(File);
+
+		resetFetch();
+	});
+
+	it('should initialize using the static method', async () => {
+		const file = new File([], 'file.mp4', { type: 'video/mp4' });
+		const source = await Source.from(file);
+
+		expect(source).toBeInstanceOf(Source);
+		expect(source.name).toBe('file.mp4');
+	});
 });

src/sources/source.ts

@@ -190,7 +190,7 @@ export class Source extends EventEmitterMixin<Events, typeof Serializer>(Seriali
 	 * as an html element
 	 */
 	public async thumbnail(): Promise<HTMLElement> {
-		return new HTMLElement();
+		return document.createElement('div');
 	}
 
 	/**