359 lines
12 KiB
C++
359 lines
12 KiB
C++
//
|
|
// Copyright (c) 2013-2025 The SRS Authors
|
|
//
|
|
// SPDX-License-Identifier: MIT
|
|
//
|
|
|
|
#ifndef SRS_UTEST_APP9_HPP
|
|
#define SRS_UTEST_APP9_HPP
|
|
|
|
/*
|
|
#include <srs_utest_app9.hpp>
|
|
*/
|
|
#include <srs_utest.hpp>
|
|
|
|
#include <srs_app_config.hpp>
|
|
#include <srs_app_dash.hpp>
|
|
#include <srs_app_dvr.hpp>
|
|
#include <srs_app_factory.hpp>
|
|
#include <srs_app_forward.hpp>
|
|
#include <srs_app_hds.hpp>
|
|
#include <srs_app_hls.hpp>
|
|
#include <srs_app_ng_exec.hpp>
|
|
#include <srs_app_rtmp_source.hpp>
|
|
#include <srs_app_statistic.hpp>
|
|
#include <srs_kernel_packet.hpp>
|
|
#include <srs_protocol_rtmp_stack.hpp>
|
|
#include <srs_utest_app6.hpp>
|
|
#ifdef SRS_HDS
|
|
#include <srs_app_hds.hpp>
|
|
#endif
|
|
#include <srs_app_factory.hpp>
|
|
|
|
// Mock media packet for testing jitter correction
|
|
class MockMediaPacketForJitter : public SrsMediaPacket
|
|
{
|
|
public:
|
|
MockMediaPacketForJitter(int64_t timestamp, bool is_av);
|
|
virtual ~MockMediaPacketForJitter();
|
|
};
|
|
|
|
// Mock live source for testing message queue dump_packets
|
|
class MockLiveSourceForQueue : public SrsLiveSource
|
|
{
|
|
public:
|
|
MockLiveSourceForQueue();
|
|
virtual ~MockLiveSourceForQueue();
|
|
virtual void on_consumer_destroy(SrsLiveConsumer *consumer);
|
|
virtual srs_error_t initialize(SrsSharedPtr<SrsLiveSource> wrapper, ISrsRequest *r);
|
|
virtual void update_auth(ISrsRequest *r);
|
|
virtual srs_error_t consumer_dumps(ISrsLiveConsumer *consumer, bool ds, bool dm, bool dg);
|
|
};
|
|
|
|
// Mock live consumer for testing message queue dump_packets
|
|
class MockLiveConsumerForQueue : public SrsLiveConsumer
|
|
{
|
|
public:
|
|
int enqueue_count_;
|
|
std::vector<int64_t> enqueued_timestamps_;
|
|
|
|
public:
|
|
MockLiveConsumerForQueue(MockLiveSourceForQueue *source);
|
|
virtual ~MockLiveConsumerForQueue();
|
|
virtual srs_error_t enqueue(SrsMediaPacket *shared_msg, bool atc, SrsRtmpJitterAlgorithm ag);
|
|
};
|
|
|
|
// Mock media packet for testing gop cache with H.264 video
|
|
class MockH264VideoPacket : public SrsMediaPacket
|
|
{
|
|
public:
|
|
MockH264VideoPacket(bool is_keyframe);
|
|
virtual ~MockH264VideoPacket();
|
|
};
|
|
|
|
// Mock media packet for testing gop cache with audio
|
|
class MockAudioPacket : public SrsMediaPacket
|
|
{
|
|
public:
|
|
MockAudioPacket();
|
|
virtual ~MockAudioPacket();
|
|
};
|
|
|
|
// Mock ISrsHls for testing SrsOriginHub::initialize
|
|
class MockHlsForOriginHub : public ISrsHls
|
|
{
|
|
public:
|
|
int initialize_count_;
|
|
srs_error_t initialize_error_;
|
|
srs_utime_t cleanup_delay_;
|
|
int on_audio_count_;
|
|
int on_video_count_;
|
|
|
|
public:
|
|
MockHlsForOriginHub();
|
|
virtual ~MockHlsForOriginHub();
|
|
virtual srs_error_t initialize(SrsOriginHub *h, ISrsRequest *r);
|
|
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
|
|
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
|
|
virtual srs_error_t on_publish();
|
|
virtual void on_unpublish();
|
|
virtual void dispose();
|
|
virtual srs_error_t cycle();
|
|
virtual srs_utime_t cleanup_delay();
|
|
};
|
|
|
|
// Mock ISrsDash for testing SrsOriginHub::initialize
|
|
class MockDashForOriginHub : public ISrsDash
|
|
{
|
|
public:
|
|
int initialize_count_;
|
|
srs_error_t initialize_error_;
|
|
srs_utime_t cleanup_delay_;
|
|
int on_audio_count_;
|
|
int on_video_count_;
|
|
|
|
public:
|
|
MockDashForOriginHub();
|
|
virtual ~MockDashForOriginHub();
|
|
virtual srs_error_t initialize(ISrsOriginHub *h, ISrsRequest *r);
|
|
virtual srs_error_t on_publish();
|
|
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
|
|
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
|
|
virtual void on_unpublish();
|
|
virtual void dispose();
|
|
virtual srs_error_t cycle();
|
|
virtual srs_utime_t cleanup_delay();
|
|
};
|
|
|
|
// Mock ISrsDvr for testing SrsOriginHub::initialize
|
|
class MockDvrForOriginHub : public ISrsDvr
|
|
{
|
|
public:
|
|
int initialize_count_;
|
|
srs_error_t initialize_error_;
|
|
int on_meta_data_count_;
|
|
int on_audio_count_;
|
|
int on_video_count_;
|
|
|
|
public:
|
|
MockDvrForOriginHub();
|
|
virtual void assemble();
|
|
virtual ~MockDvrForOriginHub();
|
|
virtual srs_error_t initialize(ISrsOriginHub *h, ISrsRequest *r);
|
|
virtual srs_error_t on_publish(ISrsRequest *r);
|
|
virtual void on_unpublish();
|
|
virtual srs_error_t on_meta_data(SrsMediaPacket *metadata);
|
|
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
|
|
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
|
|
};
|
|
|
|
// Mock ISrsForwarder for testing SrsOriginHub::on_meta_data
|
|
class MockForwarderForOriginHub : public ISrsForwarder
|
|
{
|
|
public:
|
|
int on_meta_data_count_;
|
|
int on_audio_count_;
|
|
int on_video_count_;
|
|
|
|
public:
|
|
MockForwarderForOriginHub();
|
|
virtual ~MockForwarderForOriginHub();
|
|
virtual srs_error_t initialize(ISrsRequest *r, std::string ep);
|
|
virtual void set_queue_size(srs_utime_t queue_size);
|
|
virtual srs_error_t on_publish();
|
|
virtual void on_unpublish();
|
|
virtual srs_error_t on_meta_data(SrsMediaPacket *shared_metadata);
|
|
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio);
|
|
virtual srs_error_t on_video(SrsMediaPacket *shared_video);
|
|
};
|
|
|
|
// Mock ISrsLiveSource for testing SrsOriginHub::on_audio
|
|
class MockLiveSourceForOriginHub : public ISrsLiveSource
|
|
{
|
|
// clang-format off
|
|
SRS_DECLARE_PRIVATE: // clang-format on
|
|
SrsRtmpFormat *format_;
|
|
SrsMetaCache *meta_;
|
|
|
|
public:
|
|
MockLiveSourceForOriginHub();
|
|
virtual ~MockLiveSourceForOriginHub();
|
|
virtual void on_consumer_destroy(SrsLiveConsumer *consumer);
|
|
virtual SrsContextId source_id();
|
|
virtual SrsContextId pre_source_id();
|
|
virtual SrsMetaCache *meta();
|
|
virtual SrsRtmpFormat *format();
|
|
virtual srs_error_t on_source_id_changed(SrsContextId id);
|
|
virtual srs_error_t on_publish();
|
|
virtual void on_unpublish();
|
|
virtual srs_error_t on_audio(SrsRtmpCommonMessage *audio);
|
|
virtual srs_error_t on_video(SrsRtmpCommonMessage *video);
|
|
virtual srs_error_t on_aggregate(SrsRtmpCommonMessage *msg);
|
|
virtual srs_error_t on_meta_data(SrsRtmpCommonMessage *msg, SrsOnMetaDataPacket *metadata);
|
|
};
|
|
|
|
// Mock ISrsStatistic for testing SrsOriginHub::on_video
|
|
class MockStatisticForOriginHub : public ISrsStatistic
|
|
{
|
|
public:
|
|
int on_video_info_count_;
|
|
int on_audio_info_count_;
|
|
|
|
public:
|
|
MockStatisticForOriginHub();
|
|
virtual ~MockStatisticForOriginHub();
|
|
virtual void on_disconnect(std::string id, srs_error_t err);
|
|
virtual srs_error_t on_client(std::string id, ISrsRequest *req, ISrsExpire *conn, SrsRtmpConnType type);
|
|
virtual srs_error_t on_video_info(ISrsRequest *req, SrsVideoCodecId vcodec, int avc_profile, int avc_level, int width, int height);
|
|
virtual srs_error_t on_audio_info(ISrsRequest *req, SrsAudioCodecId acodec, SrsAudioSampleRate asample_rate, SrsAudioChannels asound_type, SrsAacObjectType aac_object);
|
|
virtual void on_stream_publish(ISrsRequest *req, std::string publisher_id);
|
|
virtual void on_stream_close(ISrsRequest *req);
|
|
virtual void kbps_add_delta(std::string id, ISrsKbpsDelta *delta);
|
|
virtual void kbps_sample();
|
|
virtual srs_error_t on_video_frames(ISrsRequest *req, int nb_frames);
|
|
virtual std::string server_id();
|
|
virtual std::string service_id();
|
|
virtual std::string service_pid();
|
|
virtual SrsStatisticVhost *find_vhost_by_id(std::string vid);
|
|
virtual SrsStatisticStream *find_stream(std::string sid);
|
|
virtual SrsStatisticStream *find_stream_by_url(std::string url);
|
|
virtual SrsStatisticClient *find_client(std::string client_id);
|
|
virtual srs_error_t dumps_vhosts(SrsJsonArray *arr);
|
|
virtual srs_error_t dumps_streams(SrsJsonArray *arr, int start, int count);
|
|
virtual srs_error_t dumps_clients(SrsJsonArray *arr, int start, int count);
|
|
virtual srs_error_t dumps_metrics(int64_t &send_bytes, int64_t &recv_bytes, int64_t &nstreams, int64_t &nclients, int64_t &total_nclients, int64_t &nerrs);
|
|
};
|
|
|
|
// Mock ISrsNgExec for testing SrsOriginHub::on_publish
|
|
class MockNgExecForOriginHub : public ISrsNgExec
|
|
{
|
|
public:
|
|
int on_publish_count_;
|
|
|
|
public:
|
|
MockNgExecForOriginHub();
|
|
virtual ~MockNgExecForOriginHub();
|
|
virtual srs_error_t on_publish(ISrsRequest *req);
|
|
virtual void on_unpublish();
|
|
virtual srs_error_t cycle();
|
|
};
|
|
|
|
#ifdef SRS_HDS
|
|
// Mock ISrsHds for testing SrsOriginHub::on_publish
|
|
class MockHdsForOriginHub : public ISrsHds
|
|
{
|
|
public:
|
|
int on_publish_count_;
|
|
|
|
public:
|
|
MockHdsForOriginHub();
|
|
virtual ~MockHdsForOriginHub();
|
|
virtual srs_error_t on_publish(ISrsRequest *req);
|
|
virtual srs_error_t on_unpublish();
|
|
virtual srs_error_t on_video(SrsMediaPacket *msg);
|
|
virtual srs_error_t on_audio(SrsMediaPacket *msg);
|
|
};
|
|
#endif
|
|
|
|
// Mock config for testing SrsOriginHub::create_forwarders
|
|
class MockAppConfigForForwarder : public MockAppConfig
|
|
{
|
|
public:
|
|
SrsConfDirective *forwards_directive_;
|
|
SrsConfDirective *backend_directive_;
|
|
|
|
public:
|
|
MockAppConfigForForwarder();
|
|
virtual ~MockAppConfigForForwarder();
|
|
virtual bool get_forward_enabled(std::string vhost);
|
|
virtual SrsConfDirective *get_forwards(std::string vhost);
|
|
virtual SrsConfDirective *get_forward_backend(std::string vhost);
|
|
void set_forward_destinations(const std::vector<std::string> &destinations);
|
|
void set_forward_backend(const std::string &backend_url);
|
|
};
|
|
|
|
// Mock HTTP hooks for testing SrsOriginHub::create_backend_forwarders
|
|
class MockHttpHooksForBackend : public MockHttpHooks
|
|
{
|
|
public:
|
|
std::vector<std::string> backend_urls_;
|
|
int on_forward_backend_count_;
|
|
|
|
public:
|
|
MockHttpHooksForBackend();
|
|
virtual ~MockHttpHooksForBackend();
|
|
virtual srs_error_t on_forward_backend(std::string url, ISrsRequest *req, std::vector<std::string> &rtmp_urls);
|
|
void set_backend_urls(const std::vector<std::string> &urls);
|
|
};
|
|
|
|
// Mock ISrsHourGlass for testing SrsLiveSourceManager::setup_ticks
|
|
class MockHourGlassForSourceManager : public ISrsHourGlass
|
|
{
|
|
public:
|
|
int tick_event_;
|
|
srs_utime_t tick_interval_;
|
|
int tick_count_;
|
|
int start_count_;
|
|
srs_error_t tick_error_;
|
|
srs_error_t start_error_;
|
|
|
|
public:
|
|
MockHourGlassForSourceManager();
|
|
virtual ~MockHourGlassForSourceManager();
|
|
virtual srs_error_t start();
|
|
virtual void stop();
|
|
virtual srs_error_t tick(srs_utime_t interval);
|
|
virtual srs_error_t tick(int event, srs_utime_t interval);
|
|
virtual void untick(int event);
|
|
};
|
|
|
|
// Mock ISrsAppFactory for testing SrsLiveSourceManager::fetch_or_create
|
|
class MockAppFactoryForSourceManager : public SrsAppFactory
|
|
{
|
|
public:
|
|
int create_live_source_count_;
|
|
|
|
public:
|
|
MockAppFactoryForSourceManager();
|
|
virtual ~MockAppFactoryForSourceManager();
|
|
virtual SrsLiveSource *create_live_source();
|
|
};
|
|
|
|
// Mock ISrsOriginHub for testing SrsLiveSource::initialize
|
|
class MockOriginHubForLiveSource : public ISrsOriginHub
|
|
{
|
|
public:
|
|
int initialize_count_;
|
|
srs_error_t initialize_error_;
|
|
|
|
public:
|
|
MockOriginHubForLiveSource();
|
|
virtual ~MockOriginHubForLiveSource();
|
|
virtual srs_error_t initialize(SrsSharedPtr<SrsLiveSource> s, ISrsRequest *r);
|
|
virtual void dispose();
|
|
virtual srs_error_t cycle();
|
|
virtual bool active();
|
|
virtual srs_utime_t cleanup_delay();
|
|
virtual srs_error_t on_meta_data(SrsMediaPacket *shared_metadata, SrsOnMetaDataPacket *packet);
|
|
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio);
|
|
virtual srs_error_t on_video(SrsMediaPacket *shared_video, bool is_sequence_header);
|
|
virtual srs_error_t on_publish();
|
|
virtual void on_unpublish();
|
|
virtual srs_error_t on_dvr_request_sh();
|
|
};
|
|
|
|
// Mock ISrsAppFactory for testing SrsLiveSource::initialize
|
|
class MockAppFactoryForLiveSource : public SrsAppFactory
|
|
{
|
|
public:
|
|
MockOriginHubForLiveSource *mock_hub_;
|
|
int create_origin_hub_count_;
|
|
|
|
public:
|
|
MockAppFactoryForLiveSource();
|
|
virtual ~MockAppFactoryForLiveSource();
|
|
virtual ISrsOriginHub *create_origin_hub();
|
|
};
|
|
|
|
#endif
|