alex.zinn/ToolsRtmpPush
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add .nvmrc

Browse Source
This commit is contained in:
Alexander Zinn
2025-08-17 15:37:42 -04:00
parent ceab5680dd
commit 511408b858
9 changed files with 241 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

306
tests/RtmpPush.test.ts
View File

@@ -1,10 +1,10 @@
import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
import { RtmpPush } from "../src/RtmpPush.js";
import {describe, it, expect, beforeEach, afterEach, mock} from 'bun:test';
import {RtmpPush} from '../src/RtmpPush.js';
// Mock the child_process module
const mockProcess = {
stdout: { on: mock(() => {}) },
stderr: { on: mock(() => {}) },
stdout: {on: mock(() => {})},
stderr: {on: mock(() => {})},
on: mock(() => {}),
kill: mock(() => {}),
killed: false
@@ -12,14 +12,14 @@ const mockProcess = {
const mockSpawn = mock(() => mockProcess);
mock.module("node:child_process", () => ({
mock.module('node:child_process', () => ({
spawn: mockSpawn
}));
describe("RtmpPush", () => {
describe('RtmpPush', () => {
let rtmpPush: RtmpPush;
const mockMediaSourceUri = "https://example.com/test-video.ts";
const mockRtmpIngestUri = "rtmp://ingest.example.com:80/ingest";
const mockMediaSourceUri = 'https://example.com/test-video.ts';
const mockRtmpIngestUri = 'rtmp://ingest.example.com:80/ingest';
beforeEach(() => {
rtmpPush = new RtmpPush(mockMediaSourceUri, mockRtmpIngestUri);
@@ -38,272 +38,262 @@ describe("RtmpPush", () => {
}
});
describe("Constructor", () => {
it("should create instance with correct properties", () => {
describe('Constructor', () => {
it('should create instance with correct properties', () => {
expect(rtmpPush).toBeInstanceOf(RtmpPush);
expect(rtmpPush.mediaSourceUri).toBe(mockMediaSourceUri);
expect(rtmpPush.rtmpIngestUri).toBe(mockRtmpIngestUri);
});
it("should handle empty strings", () => {
const emptyRtmpPush = new RtmpPush("", "");
expect(emptyRtmpPush.mediaSourceUri).toBe("");
expect(emptyRtmpPush.rtmpIngestUri).toBe("");
it('should handle empty strings', () => {
const emptyRtmpPush = new RtmpPush('', '');
expect(emptyRtmpPush.mediaSourceUri).toBe('');
expect(emptyRtmpPush.rtmpIngestUri).toBe('');
});
});
describe("Getters", () => {
it("should return correct mediaSourceUri", () => {
describe('Getters', () => {
it('should return correct mediaSourceUri', () => {
expect(rtmpPush.mediaSourceUri).toBe(mockMediaSourceUri);
});
it("should return correct rtmpIngestUri", () => {
it('should return correct rtmpIngestUri', () => {
expect(rtmpPush.rtmpIngestUri).toBe(mockRtmpIngestUri);
});
it("should return immutable values", () => {
it('should return immutable values', () => {
const originalMediaUri = rtmpPush.mediaSourceUri;
const originalRtmpUri = rtmpPush.rtmpIngestUri;
// These should not change the internal state
expect(rtmpPush.mediaSourceUri).toBe(originalMediaUri);
expect(rtmpPush.rtmpIngestUri).toBe(originalRtmpUri);
});
});
describe("start() method", () => {
it("should start RTMP push process with correct parameters", () => {
const streamKey = "test-stream-123";
const capabilities = ["h264", "aac"];
describe('start() method', () => {
it('should start RTMP push process with correct parameters', () => {
const streamKey = 'test-stream-123';
const capabilities = ['h264', 'aac'];
const result = rtmpPush.start(streamKey, capabilities);
expect(result).toBe(rtmpPush);
expect(rtmpPush.isRunning()).toBe(true);
});
it("should construct correct ffmpeg command", () => {
const streamKey = "test-stream";
const capabilities = ["h264", "aac"];
it('should construct correct ffmpeg command', () => {
const streamKey = 'test-stream';
const capabilities = ['h264', 'aac'];
rtmpPush.start(streamKey, capabilities);
expect(mockSpawn).toHaveBeenCalledWith(
"ffmpeg",
'ffmpeg',
expect.arrayContaining([
"-re",
"-hide_banner",
"-stream_loop", "-1",
"-y",
"-flags", "low_delay",
"-fflags", "+nobuffer+flush_packets",
"-i", mockMediaSourceUri,
"-c:a", "copy",
"-c:v", "copy",
"-flush_packets", "1",
"-copyts",
"-f", "flv"
'-re',
'-hide_banner',
'-stream_loop',
'-1',
'-y',
'-flags',
'low_delay',
'-fflags',
'+nobuffer+flush_packets',
'-i',
mockMediaSourceUri,
'-c:a',
'copy',
'-c:v',
'copy',
'-flush_packets',
'1',
'-copyts',
'-f',
'flv'
])
);
});
it("should construct correct ingest URI", () => {
const streamKey = "test-stream";
const capabilities = ["h264", "aac"];
it('should construct correct ingest URI', () => {
const streamKey = 'test-stream';
const capabilities = ['h264', 'aac'];
rtmpPush.start(streamKey, capabilities);
const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=${capabilities.join(',')};tags=`;
expect(mockSpawn).toHaveBeenCalledWith(
"ffmpeg",
expect.arrayContaining([expectedIngestUri])
);
expect(mockSpawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining([expectedIngestUri]));
});
it("should handle empty capabilities array", () => {
const streamKey = "test-stream";
it('should handle empty capabilities array', () => {
const streamKey = 'test-stream';
const capabilities: string[] = [];
rtmpPush.start(streamKey, capabilities);
const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=;tags=`;
expect(mockSpawn).toHaveBeenCalledWith(
"ffmpeg",
expect.arrayContaining([expectedIngestUri])
);
expect(mockSpawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining([expectedIngestUri]));
});
it("should handle single capability", () => {
const streamKey = "test-stream";
const capabilities = ["h264"];
it('should handle single capability', () => {
const streamKey = 'test-stream';
const capabilities = ['h264'];
rtmpPush.start(streamKey, capabilities);
const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=h264;tags=`;
expect(mockSpawn).toHaveBeenCalledWith(
"ffmpeg",
expect.arrayContaining([expectedIngestUri])
);
expect(mockSpawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining([expectedIngestUri]));
});
it("should set up process event handlers", () => {
const streamKey = "test-stream";
const capabilities = ["h264"];
it('should set up process event handlers', () => {
const streamKey = 'test-stream';
const capabilities = ['h264'];
rtmpPush.start(streamKey, capabilities);
expect(mockProcess.stdout.on).toHaveBeenCalledWith("data", expect.any(Function));
expect(mockProcess.stderr.on).toHaveBeenCalledWith("data", expect.any(Function));
expect(mockProcess.on).toHaveBeenCalledWith("close", expect.any(Function));
expect(mockProcess.on).toHaveBeenCalledWith("error", expect.any(Function));
expect(mockProcess.stdout.on).toHaveBeenCalledWith('data', expect.any(Function));
expect(mockProcess.stderr.on).toHaveBeenCalledWith('data', expect.any(Function));
expect(mockProcess.on).toHaveBeenCalledWith('close', expect.any(Function));
expect(mockProcess.on).toHaveBeenCalledWith('error', expect.any(Function));
});
it("should be chainable", () => {
const streamKey = "test-stream";
const capabilities = ["h264"];
it('should be chainable', () => {
const streamKey = 'test-stream';
const capabilities = ['h264'];
const result = rtmpPush.start(streamKey, capabilities);
expect(result).toBe(rtmpPush);
});
});
describe("stop() method", () => {
it("should stop running process", () => {
const streamKey = "test-stream";
const capabilities = ["h264"];
describe('stop() method', () => {
it('should stop running process', () => {
const streamKey = 'test-stream';
const capabilities = ['h264'];
rtmpPush.start(streamKey, capabilities);
expect(rtmpPush.isRunning()).toBe(true);
const result = rtmpPush.stop();
expect(result).toBe(rtmpPush);
expect(rtmpPush.isRunning()).toBe(false);
});
it("should handle stopping when no process is running", () => {
it('should handle stopping when no process is running', () => {
expect(rtmpPush.isRunning()).toBe(false);
const result = rtmpPush.stop();
expect(result).toBe(rtmpPush);
expect(rtmpPush.isRunning()).toBe(false);
});
it("should be chainable", () => {
it('should be chainable', () => {
const result = rtmpPush.stop();
expect(result).toBe(rtmpPush);
});
});
describe("isRunning() method", () => {
it("should return false when no process is started", () => {
describe('isRunning() method', () => {
it('should return false when no process is started', () => {
expect(rtmpPush.isRunning()).toBe(false);
});
it("should return true when process is running", () => {
const streamKey = "test-stream";
const capabilities = ["h264"];
it('should return true when process is running', () => {
const streamKey = 'test-stream';
const capabilities = ['h264'];
rtmpPush.start(streamKey, capabilities);
expect(rtmpPush.isRunning()).toBe(true);
});
it("should return false after process is stopped", () => {
const streamKey = "test-stream";
const capabilities = ["h264"];
it('should return false after process is stopped', () => {
const streamKey = 'test-stream';
const capabilities = ['h264'];
rtmpPush.start(streamKey, capabilities);
expect(rtmpPush.isRunning()).toBe(true);
rtmpPush.stop();
expect(rtmpPush.isRunning()).toBe(false);
});
});
describe("Process lifecycle", () => {
it("should handle process close event", () => {
const streamKey = "test-stream";
const capabilities = ["h264"];
describe('Process lifecycle', () => {
it('should handle process close event', () => {
const streamKey = 'test-stream';
const capabilities = ['h264'];
rtmpPush.start(streamKey, capabilities);
// Simulate process close
const closeHandler = mockProcess.on.mock.calls.find(call => call[0] === "close")?.[1];
const closeHandler = mockProcess.on.mock.calls.find(call => call[0] === 'close')?.[1];
if (closeHandler && typeof closeHandler === 'function') {
closeHandler(0);
}
expect(rtmpPush.isRunning()).toBe(false);
});
it("should handle process error event", () => {
const streamKey = "test-stream";
const capabilities = ["h264"];
it('should handle process error event', () => {
const streamKey = 'test-stream';
const capabilities = ['h264'];
rtmpPush.start(streamKey, capabilities);
// Simulate process error
const errorHandler = mockProcess.on.mock.calls.find(call => call[0] === "error")?.[1];
const errorHandler = mockProcess.on.mock.calls.find(call => call[0] === 'error')?.[1];
if (errorHandler && typeof errorHandler === 'function') {
// Call the error handler with a mock error
errorHandler(new Error("Process error"));
errorHandler(new Error('Process error'));
}
// The error handler should set the process to null
expect(rtmpPush.isRunning()).toBe(false);
});
});
describe("Edge cases", () => {
it("should handle special characters in stream key", () => {
const streamKey = "test-stream-with-special-chars!@#$%^&*()";
const capabilities = ["h264"];
describe('Edge cases', () => {
it('should handle special characters in stream key', () => {
const streamKey = 'test-stream-with-special-chars!@#$%^&*()';
const capabilities = ['h264'];
rtmpPush.start(streamKey, capabilities);
const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=${capabilities.join(',')};tags=`;
expect(mockSpawn).toHaveBeenCalledWith(
"ffmpeg",
expect.arrayContaining([expectedIngestUri])
);
expect(mockSpawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining([expectedIngestUri]));
});
it("should handle special characters in capabilities", () => {
const streamKey = "test-stream";
const capabilities = ["h.264", "aac-lc", "stereo_audio"];
it('should handle special characters in capabilities', () => {
const streamKey = 'test-stream';
const capabilities = ['h.264', 'aac-lc', 'stereo_audio'];
rtmpPush.start(streamKey, capabilities);
const expectedIngestUri = `${mockRtmpIngestUri}/${streamKey};capabilities=${capabilities.join(',')};tags=`;
expect(mockSpawn).toHaveBeenCalledWith(
"ffmpeg",
expect.arrayContaining([expectedIngestUri])
);
expect(mockSpawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining([expectedIngestUri]));
});
it("should handle very long URIs", () => {
const longMediaUri = "https://example.com/" + "a".repeat(1000) + ".ts";
const longRtmpUri = "rtmp://ingest.example.com:80/ingest/" + "b".repeat(1000);
it('should handle very long URIs', () => {
const longMediaUri = 'https://example.com/' + 'a'.repeat(1000) + '.ts';
const longRtmpUri = 'rtmp://ingest.example.com:80/ingest/' + 'b'.repeat(1000);
const longRtmpPush = new RtmpPush(longMediaUri, longRtmpUri);
const streamKey = "test-stream";
const capabilities = ["h264"];
const streamKey = 'test-stream';
const capabilities = ['h264'];
longRtmpPush.start(streamKey, capabilities);
const expectedIngestUri = `${longRtmpUri}/${streamKey};capabilities=${capabilities.join(',')};tags=`;
expect(mockSpawn).toHaveBeenCalledWith(
"ffmpeg",
expect.arrayContaining([expectedIngestUri])
);
expect(mockSpawn).toHaveBeenCalledWith('ffmpeg', expect.arrayContaining([expectedIngestUri]));
});
});
});