🎥 Make videos programmatically with React
import {afterEach, beforeEach, expect, test} from 'bun:test';
import {act, cleanup, fireEvent, render, waitFor} from '@testing-library/react';
import React from 'react';
import type {
EffectApplyParams,
EffectDefinition,
EffectDescriptor,
} from '../effects/effect-types.js';
import {Img, imgSchema} from '../Img.js';
import type {RemotionEnvironment} from '../remotion-environment-context.js';
import {RemotionEnvironmentContext} from '../remotion-environment-context.js';
import type {SequenceContextType} from '../SequenceContext.js';
import {SequenceContext} from '../SequenceContext.js';
import {SetTimelineContext} from '../TimelineContext.js';
import {WrapSequenceContext} from './wrap-sequence-context.js';
const drawImageCalls: unknown[][] = [];
const imageCrossOrigins: Array<string | null> = [];
const OriginalImage = globalThis.Image;
const stub2dContext = () => ({
fillStyle: '',
fillRect: () => undefined,
clearRect: () => undefined,
drawImage: (...args: unknown[]) => {
drawImageCalls.push(args);
},
reset: () => undefined,
getImageData: () => ({
data: new Uint8ClampedArray(4),
width: 1,
height: 1,
}),
putImageData: () => undefined,
});
Object.defineProperty(HTMLCanvasElement.prototype, 'getContext', {
configurable: true,
value: (kind: string) => {
if (kind === '2d') {
return stub2dContext();
}
return null;
},
});
class MockImage {
public onload: (() => void) | null = null;
public onerror: (() => void) | null = null;
public crossOrigin: string | null = null;
public naturalWidth = 200;
public naturalHeight = 100;
public width = 200;
public height = 100;
public decode = () => Promise.resolve();
private currentSrc = '';
public get src() {
return this.currentSrc;
}
public set src(src: string) {
this.currentSrc = src;
imageCrossOrigins.push(this.crossOrigin);
queueMicrotask(() => this.onload?.());
}
}
const makeEffect = (
applyCalls: EffectApplyParams<unknown, unknown>[] = [],
): EffectDescriptor<unknown> => {
const definition: EffectDefinition<unknown> = {
type: 'test-effect',
label: 'Test effect',
documentationLink: null,
backend: '2d',
calculateKey: () => 'test-effect',
setup: () => ({}),
apply: (params) => {
applyCalls.push(params);
params.target
.getContext('2d')
?.drawImage(params.source, 0, 0, params.width, params.height);
},
cleanup: () => undefined,
schema: {},
validateParams: () => undefined,
};
return {
definition,
effectKey: 'test-effect',
params: {},
memoized: false,
};
};
beforeEach(() => {
drawImageCalls.length = 0;
imageCrossOrigins.length = 0;
globalThis.Image = MockImage as unknown as typeof Image;
});
afterEach(() => {
cleanup();
globalThis.Image = OriginalImage;
});
const testImgUrl = 'https://source.unsplash.com/random/50x50';
const previewEnvironment: RemotionEnvironment = {
isClientSideRendering: false,
isPlayer: false,
isReadOnlyStudio: false,
isRendering: false,
isStudio: false,
};
const wrapImg = (
element: React.ReactElement,
environment: RemotionEnvironment = previewEnvironment,
currentFrame: number = 0,
) => {
return (
<RemotionEnvironmentContext.Provider value={environment}>
<WrapSequenceContext currentFrame={currentFrame}>
{element}
</WrapSequenceContext>
</RemotionEnvironmentContext.Provider>
);
};
const renderImg = (
element: React.ReactElement,
environment: RemotionEnvironment = previewEnvironment,
) => {
return render(wrapImg(element, environment));
};
const makeSequenceContext = (premounting: boolean): SequenceContextType => ({
playbackRate: 1,
absoluteFrom: 0,
cumulatedFrom: 0,
cumulatedNegativeFrom: 0,
durationInFrames: 100,
height: 1080,
id: 'parent',
parentFrom: 0,
postmountDisplay: null,
postmounting: false,
premountDisplay: null,
premounting,
relativeFrom: 0,
width: 1080,
});
const BufferingEvents: React.FC<{
readonly events: string[];
}> = ({events}) => {
const {subscribeBuffering} = React.useContext(SetTimelineContext);
React.useLayoutEffect(() => {
return subscribeBuffering((state) => {
events.push(state.buffering ? 'waiting' : 'resume');
});
}, [events, subscribeBuffering]);
return null;
};
const forceNodeEnv = (nodeEnv: string) => {
const originalNodeEnv = window.process.env.NODE_ENV;
window.process.env.NODE_ENV = nodeEnv;
return () => {
window.process.env.NODE_ENV = originalNodeEnv;
};
};
const imgInSequence = ({
events,
premounting,
}: {
readonly events?: string[];
readonly premounting: boolean;
}) => (
<SequenceContext.Provider value={makeSequenceContext(premounting)}>
{events ? <BufferingEvents events={events} /> : null}
<Img src="blob:http://localhost/test-image" pauseWhenLoading />
</SequenceContext.Provider>
);
test('Img component renders img tag', () => {
const ref = React.createRef<HTMLImageElement>();
renderImg(<Img ref={ref} src={testImgUrl} />);
expect(ref.current?.tagName).toBe('IMG');
});
test('Src attribute is forwarded to img tag', () => {
const ref = React.createRef<HTMLImageElement>();
renderImg(<Img ref={ref} src={testImgUrl} />);
expect(ref.current).toHaveProperty('src', testImgUrl);
});
test('Img does not force synchronous decoding outside of rendering', () => {
const ref = React.createRef<HTMLImageElement>();
renderImg(<Img ref={ref} src={testImgUrl} />);
expect(ref.current?.getAttribute('decoding')).toBeNull();
});
test('Img preserves the decoding prop outside of rendering', () => {
const ref = React.createRef<HTMLImageElement>();
renderImg(<Img ref={ref} src={testImgUrl} decoding="async" />);
expect(ref.current?.getAttribute('decoding')).toBe('async');
});
test('Img forces synchronous decoding while rendering', () => {
const ref = React.createRef<HTMLImageElement>();
renderImg(<Img ref={ref} src={testImgUrl} decoding="async" />, {
...previewEnvironment,
isRendering: true,
});
expect(ref.current?.getAttribute('decoding')).toBe('sync');
});
test('Img with an empty effects array still renders an img tag', () => {
const ref = React.createRef<HTMLImageElement>();
renderImg(<Img ref={ref} src={testImgUrl} effects={[]} />);
expect(ref.current?.tagName).toBe('IMG');
});
test('<Img> forwards crossOrigin when effects use <CanvasImage>', async () => {
renderImg(
<Img
src={testImgUrl}
width={50}
height={50}
effects={[makeEffect()]}
crossOrigin="use-credentials"
/>,
);
await waitFor(() => {
expect(imageCrossOrigins).toEqual(['use-credentials']);
});
});
test('<Img> calls onImageError for native and canvas image failures', async () => {
const nativeError = {current: null as Error | null};
const {container, unmount} = renderImg(
<Img
src={testImgUrl}
maxRetries={0}
onImageError={(error) => {
nativeError.current = error;
}}
/>,
);
fireEvent.error(container.querySelector('img') as HTMLImageElement);
expect(nativeError.current).toBeInstanceOf(Error);
unmount();
class FailingImage extends MockImage {
public get src() {
return '';
}
public set src(_src: string) {
queueMicrotask(() => this.onerror?.());
}
}
globalThis.Image = FailingImage as unknown as typeof Image;
const canvasError = {current: null as Error | null};
renderImg(
<Img
src={testImgUrl}
width={50}
height={50}
effects={[makeEffect()]}
maxRetries={0}
onImageError={(error) => {
canvasError.current = error;
}}
/>,
);
await waitFor(() => {
expect(canvasError.current).toBeInstanceOf(Error);
});
});
test('<Img> does not decode again when premounting ends after loading', async () => {
const originalDecode = HTMLImageElement.prototype.decode;
const restoreNodeEnv = forceNodeEnv('development');
let decodeCalls = 0;
HTMLImageElement.prototype.decode = () => {
decodeCalls++;
return Promise.resolve();
};
try {
const {rerender} = render(wrapImg(imgInSequence({premounting: true})));
await waitFor(() => {
expect(decodeCalls).toBe(1);
});
rerender(wrapImg(imgInSequence({premounting: false})));
expect(decodeCalls).toBe(1);
} finally {
HTMLImageElement.prototype.decode = originalDecode;
restoreNodeEnv();
}
});
test('<Img> buffers playback when premounting ends before loading finishes', async () => {
const originalDecode = HTMLImageElement.prototype.decode;
const restoreNodeEnv = forceNodeEnv('development');
const events: string[] = [];
let decodeResolver: (() => void) | null = null;
HTMLImageElement.prototype.decode = () =>
new Promise<void>((resolve) => {
decodeResolver = resolve;
});
try {
const {rerender} = render(
wrapImg(imgInSequence({events, premounting: true})),
);
await waitFor(() => {
expect(decodeResolver).not.toBeNull();
});
expect(events).toEqual([]);
rerender(wrapImg(imgInSequence({events, premounting: false})));
await waitFor(() => {
expect(events).toEqual(['waiting']);
});
act(() => {
decodeResolver?.();
});
await waitFor(() => {
expect(events).toEqual(['waiting', 'resume']);
});
} finally {
HTMLImageElement.prototype.decode = originalDecode;
restoreNodeEnv();
}
});
test('<Img> does not pause playback while directly premounted', async () => {
const originalDecode = HTMLImageElement.prototype.decode;
const restoreNodeEnv = forceNodeEnv('development');
const events: string[] = [];
let decodeResolver: (() => void) | null = null;
HTMLImageElement.prototype.decode = () =>
new Promise<void>((resolve) => {
decodeResolver = resolve;
});
const img = (
<>
<BufferingEvents events={events} />
<Img
src="blob:http://localhost/test-image"
from={10}
durationInFrames={20}
premountFor={10}
pauseWhenLoading
/>
</>
);
try {
const {rerender} = render(wrapImg(img, previewEnvironment, 0));
await waitFor(() => {
expect(decodeResolver).not.toBeNull();
});
expect(events).toEqual([]);
rerender(wrapImg(img, previewEnvironment, 10));
await waitFor(() => {
expect(events).toEqual(['waiting']);
});
act(() => {
decodeResolver?.();
});
await waitFor(() => {
expect(events).toEqual(['waiting', 'resume']);
});
} finally {
HTMLImageElement.prototype.decode = originalDecode;
restoreNodeEnv();
}
});
test('<Img> does not pause playback while directly postmounted', async () => {
const originalDecode = HTMLImageElement.prototype.decode;
const restoreNodeEnv = forceNodeEnv('development');
const events: string[] = [];
let decodeStarted = false;
HTMLImageElement.prototype.decode = () => {
decodeStarted = true;
return new Promise<void>(() => undefined);
};
try {
render(
wrapImg(
<>
<BufferingEvents events={events} />
<Img
src="blob:http://localhost/test-image"
from={10}
durationInFrames={20}
postmountFor={10}
pauseWhenLoading
/>
</>,
previewEnvironment,
35,
),
);
await waitFor(() => {
expect(decodeStarted).toBe(true);
});
expect(events).toEqual([]);
} finally {
HTMLImageElement.prototype.decode = originalDecode;
restoreNodeEnv();
}
});
test('Img with effects renders through the canvas image path', async () => {
const applyCalls: EffectApplyParams<unknown, unknown>[] = [];
const {container} = renderImg(
<Img
src={testImgUrl}
width={100}
height={50}
effects={[makeEffect(applyCalls)]}
/>,
);
const canvas = container.querySelector('canvas');
expect(canvas?.tagName).toBe('CANVAS');
await waitFor(() => {
expect(applyCalls).toHaveLength(1);
});
expect(applyCalls[0].width).toBe(100);
expect(applyCalls[0].height).toBe(50);
});
test('<Img> schema exposes src and crop but not fit', () => {
expect(imgSchema.src).toEqual({
type: 'asset',
assetType: 'image',
default: undefined,
description: 'Source',
keyframable: false,
});
expect(Object.keys(imgSchema)).not.toContain('fit');
for (const field of ['cropLeft', 'cropRight', 'cropTop', 'cropBottom']) {
expect(field in imgSchema).toBe(true);
}
});
test('<Img> applies crop props to the native image', () => {
const {container} = renderImg(
<Img
cropBottom={0.4}
cropLeft={0.1}
cropRight={0.2}
cropTop={0.3}
src={testImgUrl}
/>,
);
const image = container.querySelector('img');
expect(image?.style.clipPath).toBe('inset(30% 20% 40% 10%)');
});
test('<Img> forwards crop props to the CanvasImage fallback', () => {
const {container} = renderImg(
<Img
cropBottom={0.4}
cropLeft={0.1}
cropRight={0.2}
cropTop={0.3}
effects={[makeEffect()]}
src={testImgUrl}
/>,
);
const canvas = container.querySelector('canvas');
expect(canvas?.style.clipPath).toBe('inset(30% 20% 40% 10%)');
});
test('<Img> keeps its component name in crop errors from the fallback', () => {
expect(() =>
renderImg(<Img cropLeft={101} effects={[makeEffect()]} src={testImgUrl} />),
).toThrow(
'The "cropLeft" prop of <Img /> must be between 0 and 1, but got 101. The crop range is 0 to 1, not 0 to 100.',
);
});
test('Img throws when native image props conflict with effects', () => {
expect(() =>
renderImg(
<Img
src={testImgUrl}
srcSet={`${testImgUrl} 1x`}
effects={[makeEffect()]}
/>,
),
).toThrow(
'The "srcSet" prop cannot be used on <Img> when effects are passed',
);
});
test('Img forwards canvas-compatible attributes when effects are passed', async () => {
const onClick = () => {
drawImageCalls.push(['clicked']);
};
const {container} = renderImg(
<Img
src={testImgUrl}
width={100}
height={50}
effects={[makeEffect()]}
aria-label="Image with effects"
data-testid="img-effects-canvas"
role="img"
tabIndex={0}
title="Canvas image"
onClick={onClick}
/>,
);
const canvas = container.querySelector('canvas');
await waitFor(() => {
expect(canvas?.width).toBe(100);
});
expect(canvas?.getAttribute('aria-label')).toBe('Image with effects');
expect(canvas?.getAttribute('data-testid')).toBe('img-effects-canvas');
expect(canvas?.getAttribute('role')).toBe('img');
expect(canvas?.getAttribute('tabindex')).toBe('0');
expect(canvas?.getAttribute('title')).toBe('Canvas image');
fireEvent.click(canvas as HTMLCanvasElement);
expect(drawImageCalls.some((call) => call[0] === 'clicked')).toBe(true);
});
test('Img forwards objectFit to the canvas backend when effects are passed', async () => {
renderImg(
<Img
src={testImgUrl}
width={100}
height={100}
style={{objectFit: 'contain'}}
effects={[makeEffect()]}
/>,
);
await waitFor(() => {
expect(drawImageCalls.length).toBeGreaterThanOrEqual(1);
});
expect(drawImageCalls[0].slice(1)).toEqual([0, 0, 200, 100, 0, 25, 100, 50]);
});
test('Img throws when a ref is passed together with effects', () => {
const ref = React.createRef<HTMLImageElement>();
expect(() =>
renderImg(<Img ref={ref} src={testImgUrl} effects={[makeEffect()]} />),
).toThrow('The "ref" prop cannot be used on <Img> when effects are passed');
});