🎥 Make videos programmatically with React
import {afterEach, expect, spyOn, test} from 'bun:test';
import fs, {existsSync, mkdtempSync, writeFileSync} from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import type {bundle, BundleOptions} from '@remotion/bundler';
import {LambdaClientInternals} from '@remotion/lambda-client';
import {internalDeleteSite} from '../../api/delete-site';
import {internalDeploySite} from '../../api/deploy-site';
import {fakeAws, useFakeAws} from '../mocks/fake-aws';
import {getDirFiles} from '../mocks/upload-dir';
useFakeAws();
const temporaryDirectories: string[] = [];
const makeGeneratedBundle = () => {
const directory = mkdtempSync(
path.join(os.tmpdir(), 'remotion-generated-bundle-test-'),
);
temporaryDirectories.push(directory);
writeFileSync(path.join(directory, 'index.html'), '<html></html>');
writeFileSync(path.join(directory, 'bundle.js'), 'console.log("bundle")');
return directory;
};
const makeBucket = async () => {
const {bucketName} = await LambdaClientInternals.internalGetOrCreateBucket({
region: 'ap-northeast-1',
customCredentials: null,
enableFolderExpiry: false,
forcePathStyle: false,
skipPutAcl: false,
requestHandler: null,
logLevel: 'error',
});
return bucketName;
};
const makeBundleSite = ({
directory,
getBundle,
onStarted = () => undefined,
}: {
directory: string;
getBundle: () => Promise<string>;
onStarted?: () => void;
}) => {
fakeAws().bundleSite.mockImplementation(((options: BundleOptions) => {
options.onDirectoryCreated?.(directory);
onStarted();
return getBundle();
}) as typeof bundle);
};
const deployGeneratedBundle = ({
bucketName,
siteName,
}: {
bucketName: string;
siteName: string;
}) => {
return internalDeploySite({
bucketName,
entryPoint: 'entry-point',
region: 'ap-northeast-1',
siteName,
gitSource: null,
indent: false,
logLevel: 'error',
options: {},
privacy: 'public',
throwIfSiteExists: false,
forcePathStyle: false,
requestHandler: null,
});
};
const getRejection = <T>(promise: Promise<T>): Promise<unknown> => {
return promise.then(
() => {
throw new Error('Expected the promise to reject');
},
(error: unknown) => error,
);
};
afterEach(() => {
for (const directory of temporaryDirectories.splice(0)) {
fs.rmSync(directory, {force: true, recursive: true});
}
});
test('Should throw on wrong prefix', async () => {
await expect(
internalDeploySite({
bucketName: 'wrongprefix',
entryPoint: 'first',
region: 'us-east-1',
gitSource: null,
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
siteName: LambdaClientInternals.randomHashImplementation(),
throwIfSiteExists: true,
forcePathStyle: false,
requestHandler: null,
}),
).rejects.toThrow(/The bucketName parameter must start /);
});
test('Should throw if invalid region was passed', () => {
expect(
internalDeploySite({
bucketName: 'remotionlambda-testing',
entryPoint: 'first',
// @ts-expect-error
region: 'ap-northeast-9',
siteName: 'testing',
gitSource: null,
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: true,
forcePathStyle: false,
}),
).rejects.toThrow(/ap-northeast-9 is not a supported AWS region/);
});
test("Should throw if bucket doesn't exist", () => {
expect(
internalDeploySite({
bucketName: 'remotionlambda-non-existed',
entryPoint: 'first',
region: 'ap-northeast-1',
siteName: 'testing',
gitSource: null,
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: true,
forcePathStyle: false,
requestHandler: null,
}),
).rejects.toThrow(
/No bucket with the name remotionlambda-non-existed exists/,
);
});
test('Should apply name if given', async () => {
const {bucketName} = await LambdaClientInternals.internalGetOrCreateBucket({
region: 'ap-northeast-1',
customCredentials: null,
enableFolderExpiry: false,
forcePathStyle: false,
skipPutAcl: false,
requestHandler: null,
logLevel: 'info',
});
expect(
await internalDeploySite({
bucketName,
entryPoint: 'first',
region: 'ap-northeast-1',
siteName: 'testing',
gitSource: null,
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: true,
forcePathStyle: false,
requestHandler: null,
}),
).toEqual({
siteName: 'testing',
serveUrl:
'https://remotionlambda-apnortheast1-abcdef.s3.ap-northeast-1.amazonaws.com/sites/testing/index.html',
stats: {
deletedFiles: 0,
untouchedFiles: 0,
uploadedFiles: 3,
},
});
});
test('Should overwrite site if given siteName is already taken', async () => {
const {bucketName} = await LambdaClientInternals.internalGetOrCreateBucket({
region: 'ap-northeast-1',
customCredentials: null,
enableFolderExpiry: false,
forcePathStyle: false,
skipPutAcl: false,
requestHandler: null,
logLevel: 'info',
});
expect(
await internalDeploySite({
bucketName,
entryPoint: 'first',
region: 'ap-northeast-1',
siteName: 'testing',
gitSource: null,
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: false,
forcePathStyle: false,
requestHandler: null,
}),
).toEqual({
siteName: 'testing',
serveUrl:
'https://remotionlambda-apnortheast1-abcdef.s3.ap-northeast-1.amazonaws.com/sites/testing/index.html',
stats: {
deletedFiles: 0,
untouchedFiles: 3,
uploadedFiles: 0,
},
});
});
test('Should delete the previous site if deploying the new one', async () => {
const {bucketName} = await LambdaClientInternals.internalGetOrCreateBucket({
region: 'ap-northeast-1',
customCredentials: null,
enableFolderExpiry: false,
forcePathStyle: false,
skipPutAcl: false,
requestHandler: null,
logLevel: 'info',
});
await internalDeploySite({
bucketName,
entryPoint: 'first',
region: 'ap-northeast-1',
siteName: 'testing',
gitSource: null,
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: false,
forcePathStyle: false,
requestHandler: null,
});
await internalDeploySite({
bucketName,
entryPoint: 'second',
region: 'ap-northeast-1',
siteName: 'testing',
gitSource: null,
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: false,
forcePathStyle: false,
requestHandler: null,
});
const files = await LambdaClientInternals.lambdaLsImplementation({
bucketName,
expectedBucketOwner: null,
prefix: 'sites/testing',
region: 'ap-northeast-1',
continuationToken: undefined,
forcePathStyle: false,
requestHandler: null,
});
expect(
files
.map((f) => {
return f.Key;
})
.sort(),
).toEqual(
getDirFiles('/path/to/bundle-2')
.map((f) => {
return 'sites/testing/' + f.name;
})
.sort(),
);
});
test('Should keep the previous site if deploying the new one with different ID', async () => {
const {bucketName} = await LambdaClientInternals.internalGetOrCreateBucket({
region: 'ap-northeast-1',
customCredentials: null,
enableFolderExpiry: false,
forcePathStyle: false,
skipPutAcl: false,
requestHandler: null,
logLevel: 'info',
});
await internalDeploySite({
bucketName,
entryPoint: 'first',
region: 'ap-northeast-1',
siteName: 'testing',
gitSource: null,
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: false,
forcePathStyle: false,
requestHandler: null,
});
await internalDeploySite({
bucketName,
entryPoint: 'second',
region: 'ap-northeast-1',
siteName: 'testing-2',
gitSource: null,
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: false,
forcePathStyle: false,
requestHandler: null,
});
const files = await LambdaClientInternals.lambdaLsImplementation({
bucketName,
expectedBucketOwner: null,
prefix: 'sites/',
region: 'ap-northeast-1',
continuationToken: undefined,
forcePathStyle: false,
requestHandler: null,
});
expect(
files
.map((f) => {
return f.Key;
})
.sort(),
).toEqual(
[
...getDirFiles('/path/to/bundle-1').map((f) => {
return 'sites/testing/' + f.name;
}),
...getDirFiles('/path/to/bundle-2').map((f) => {
return 'sites/testing-2/' + f.name;
}),
].sort(),
);
await internalDeleteSite({
bucketName,
region: 'ap-northeast-1',
siteName: 'testing',
forcePathStyle: false,
onAfterItemDeleted: null,
requestHandler: null,
});
await internalDeleteSite({
bucketName,
region: 'ap-northeast-1',
siteName: 'testing-2',
forcePathStyle: false,
onAfterItemDeleted: null,
requestHandler: null,
});
});
test('Should not delete site with same prefix', async () => {
const {bucketName} = await LambdaClientInternals.internalGetOrCreateBucket({
region: 'ap-northeast-1',
customCredentials: null,
enableFolderExpiry: false,
forcePathStyle: false,
skipPutAcl: false,
requestHandler: null,
logLevel: 'info',
});
await internalDeploySite({
gitSource: null,
bucketName,
entryPoint: 'first',
region: 'ap-northeast-1',
siteName: 'my-site',
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: false,
forcePathStyle: false,
requestHandler: null,
});
await internalDeploySite({
gitSource: null,
bucketName,
entryPoint: 'second',
region: 'ap-northeast-1',
siteName: 'my-site-staging',
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: false,
forcePathStyle: false,
requestHandler: null,
});
await internalDeploySite({
gitSource: null,
bucketName,
entryPoint: 'first',
region: 'ap-northeast-1',
siteName: 'my-site',
indent: false,
logLevel: 'info',
options: {},
privacy: 'public',
throwIfSiteExists: false,
forcePathStyle: false,
requestHandler: null,
});
const files = await LambdaClientInternals.lambdaLsImplementation({
bucketName,
expectedBucketOwner: null,
prefix: 'sites/',
region: 'ap-northeast-1',
continuationToken: undefined,
forcePathStyle: false,
requestHandler: null,
});
expect(
files
.map((f) => {
return f.Key;
})
.sort(),
).toEqual(
[
// Should not delete my-site-staging (same bucket name but with suffix)
...getDirFiles('/path/to/bundle-2').map((f) => {
return 'sites/my-site-staging/' + f.name;
}),
...getDirFiles('/path/to/bundle-1').map((f) => {
return 'sites/my-site/' + f.name;
}),
].sort(),
);
});
test('Should remove a generated bundle after bundling fails', async () => {
const directory = makeGeneratedBundle();
const bucketName = await makeBucket();
const bundlingError = new Error('Bundling failed');
makeBundleSite({
directory,
getBundle: () => Promise.reject(bundlingError),
});
const error = await getRejection(
deployGeneratedBundle({
bucketName,
siteName: 'bundling-failure',
}),
);
expect(error).toBe(bundlingError);
expect(existsSync(directory)).toBe(false);
});
test('Should wait for bundling to finish after listing fails', async () => {
const directory = makeGeneratedBundle();
const bucketName = await makeBucket();
const listingError = new Error('Listing failed');
let resolveBundle: (directory: string) => void = () => undefined;
const bundlePromise = new Promise<string>((resolve) => {
resolveBundle = resolve;
});
let markBundleStarted: () => void = () => undefined;
const bundleStarted = new Promise<void>((resolve) => {
markBundleStarted = resolve;
});
makeBundleSite({
directory,
getBundle: () => bundlePromise,
onStarted: markBundleStarted,
});
fakeAws().listObjects.mockImplementation(() => Promise.reject(listingError));
let settled = false;
const observedDeployment = deployGeneratedBundle({
bucketName,
siteName: 'listing-failure',
}).then(
() => {
settled = true;
return null;
},
(reason: unknown) => {
settled = true;
return reason;
},
);
await bundleStarted;
await Promise.resolve();
expect(settled).toBe(false);
expect(existsSync(directory)).toBe(true);
resolveBundle(directory);
const error = await observedDeployment;
expect(error).toBe(listingError);
expect(existsSync(directory)).toBe(false);
});
test('Should remove a generated bundle after uploading fails', async () => {
const directory = makeGeneratedBundle();
const bucketName = await makeBucket();
const uploadError = new Error('Uploading failed');
makeBundleSite({
directory,
getBundle: () => Promise.resolve(directory),
});
fakeAws().uploadDir.mockImplementation(() => Promise.reject(uploadError));
const error = await getRejection(
deployGeneratedBundle({
bucketName,
siteName: 'upload-failure',
}),
);
expect(error).toBe(uploadError);
expect(existsSync(directory)).toBe(false);
});
test('Should finish stale file deletions before removing the generated bundle', async () => {
const directory = makeGeneratedBundle();
const bucketName = await makeBucket();
const deletionError = new Error('Deleting failed');
let deleteCount = 0;
let bundleWasRemovedDuringDeletion = false;
fakeAws().listObjects.mockImplementation(() => {
return Promise.resolve(
Array.from({length: 12}, (_, index) => ({
Key: `sites/deletion-failure/stale-${index}.js`,
ETag: 'stale-etag',
LastModified: new Date(0),
Size: 0,
})),
);
});
fakeAws().deleteFile.mockImplementation(async () => {
deleteCount++;
if (!existsSync(directory)) {
bundleWasRemovedDuringDeletion = true;
}
if (deleteCount === 1) {
throw deletionError;
}
await new Promise((resolve) => setTimeout(resolve, 1));
if (!existsSync(directory)) {
bundleWasRemovedDuringDeletion = true;
}
});
makeBundleSite({
directory,
getBundle: () => Promise.resolve(directory),
});
fakeAws().uploadDir.mockImplementation(() => Promise.resolve());
const error = await getRejection(
deployGeneratedBundle({
bucketName,
siteName: 'deletion-failure',
}),
);
expect(error).toBe(deletionError);
expect(deleteCount).toBe(12);
expect(bundleWasRemovedDuringDeletion).toBe(false);
expect(existsSync(directory)).toBe(false);
});
test('Should remove a generated bundle after a successful deployment', async () => {
const directory = makeGeneratedBundle();
const bucketName = await makeBucket();
makeBundleSite({
directory,
getBundle: () => Promise.resolve(directory),
});
const result = await deployGeneratedBundle({
bucketName,
siteName: 'successful-cleanup',
});
expect(result.stats.uploadedFiles).toBe(2);
expect(existsSync(directory)).toBe(false);
});
test('Should report a cleanup failure after a successful deployment', async () => {
const directory = makeGeneratedBundle();
const bucketName = await makeBucket();
const cleanupError = new Error('Cleanup failed');
makeBundleSite({
directory,
getBundle: () => Promise.resolve(directory),
});
const cleanupSpy = spyOn(fs, 'rmSync').mockImplementation(() => {
throw cleanupError;
});
let error: unknown;
try {
error = await getRejection(
deployGeneratedBundle({
bucketName,
siteName: 'cleanup-failure',
}),
);
} finally {
cleanupSpy.mockRestore();
}
expect(error).toBe(cleanupError);
expect(existsSync(directory)).toBe(true);
});
test('Should retain deployment and cleanup errors if both fail', async () => {
const directory = makeGeneratedBundle();
const bucketName = await makeBucket();
const deploymentError = new Error('Deployment failed');
const cleanupError = new Error('Cleanup failed');
makeBundleSite({
directory,
getBundle: () => Promise.resolve(directory),
});
fakeAws().uploadDir.mockImplementation(() => Promise.reject(deploymentError));
const cleanupSpy = spyOn(fs, 'rmSync').mockImplementation(() => {
throw cleanupError;
});
let error: unknown;
try {
error = await getRejection(
deployGeneratedBundle({
bucketName,
siteName: 'deployment-and-cleanup-failure',
}),
);
} finally {
cleanupSpy.mockRestore();
}
expect(error).toBeInstanceOf(AggregateError);
expect((error as AggregateError).errors).toEqual([
deploymentError,
cleanupError,
]);
expect((error as AggregateError).cause).toBe(deploymentError);
expect(existsSync(directory)).toBe(true);
});