🎥 Make videos programmatically with React
import unittest
from unittest.mock import patch
from remotion_lambda.remotionclient import RemotionClient, RemotionException
class TestLargePayloadCompression(unittest.TestCase):
def setUp(self):
self.client = RemotionClient(
region="us-east-1", serve_url="testbed", function_name="remotion-render"
)
def test_small_payload_uses_payload_format(self):
"""Test that small payloads use the payload format."""
small_props = {'message': 'small'}
result = self.client._serialize_input_props(small_props, 'video-or-audio')
self.assertEqual(result['type'], 'payload')
self.assertIn('payload', result)
self.assertNotIn('hash', result)
self.assertNotIn('bucketName', result)
@patch('remotion_lambda.remotionclient.RemotionClient._upload_to_s3')
@patch('remotion_lambda.remotionclient.RemotionClient._get_or_create_bucket')
def test_large_payload_uses_bucket_format(self, mock_get_bucket, mock_upload):
"""Test that large payloads use the bucket-url format."""
mock_get_bucket.return_value = 'remotionlambda-useast1-testbucket'
# Create a large payload that exceeds the limit for video-or-audio (200KB - margin)
large_data = 'x' * 200000 # 200KB of data
large_props = {'data': large_data}
result = self.client._serialize_input_props(large_props, 'video-or-audio')
self.assertEqual(result['type'], 'bucket-url')
self.assertIn('hash', result)
self.assertIn('bucketName', result)
self.assertEqual(result['bucketName'], 'remotionlambda-useast1-testbucket')
# Verify S3 upload was called
mock_upload.assert_called_once()
def test_needs_upload_logic(self):
"""Test the logic for determining when upload is needed."""
# Small payload should not need upload
self.assertFalse(self.client._needs_upload(1000, 'video-or-audio'))
self.assertFalse(self.client._needs_upload(1000, 'still'))
# Large payload for video should need upload
self.assertTrue(self.client._needs_upload(200000, 'video-or-audio'))
# Large payload for still should need upload (over 5MB)
self.assertTrue(self.client._needs_upload(5000000, 'still'))
# Medium payload for still should not need upload
self.assertFalse(self.client._needs_upload(1000000, 'still'))
def test_hash_generation(self):
"""Test that hash generation is consistent."""
payload = '{"test": "data"}'
hash1 = self.client._generate_hash(payload)
hash2 = self.client._generate_hash(payload)
self.assertEqual(hash1, hash2)
self.assertIsInstance(hash1, str)
self.assertEqual(len(hash1), 64) # SHA256 hex string length
def test_input_props_key_generation(self):
"""Test S3 key generation for input props."""
hash_value = 'test123'
key = self.client._input_props_key(hash_value)
self.assertEqual(key, 'input-props/test123.json')
def test_bucket_name_generation(self):
"""Test bucket name generation following JS SDK conventions."""
bucket_name = self.client._make_bucket_name()
# Should start with remotionlambda- prefix
self.assertTrue(bucket_name.startswith('remotionlambda-'))
# Should contain region without dashes
expected_region = self.client.region.replace('-', '')
self.assertIn(expected_region, bucket_name)
# Should be in format: remotionlambda-{region-no-dashes}-{random-hash}
parts = bucket_name.split('-')
self.assertEqual(len(parts), 3) # remotionlambda, region, hash
self.assertEqual(parts[0], 'remotionlambda')
self.assertEqual(parts[1], expected_region)
self.assertEqual(len(parts[2]), 10) # random hash should be 10 chars
@patch('remotion_lambda.remotionclient.RemotionClient._get_remotion_buckets')
def test_get_or_create_bucket_with_multiple_buckets_raises_error(
self, mock_get_buckets
):
"""Test that multiple buckets raises the correct error."""
mock_get_buckets.return_value = [
'remotionlambda-useast1-abc123',
'remotionlambda-useast1-def456',
]
with self.assertRaises(RemotionException) as context:
self.client._get_or_create_bucket()
error_message = str(context.exception)
self.assertIn('multiple buckets', error_message)
self.assertIn('remotionlambda-', error_message)
self.assertIn(
'https://remotion.dev/docs/lambda/multiple-buckets', error_message
)
if __name__ == '__main__':
unittest.main()