mediasoup 3.19.22 → 3.20.0

package/worker/mocks/include/MockShared.hpp

@@ -1,42 +1,89 @@
 #ifndef MS_MOCKS_MOCK_SHARED_HPP
 #define MS_MOCKS_MOCK_SHARED_HPP
 
-#include "SharedInterface.hpp"
-#include "mocks/include/Channel/MockChannelMessageRegistrator.hpp"
 #include "Channel/ChannelNotifier.hpp"
 #include "Channel/ChannelSocket.hpp"
-#include "handles/BackoffTimerHandleInterface.hpp"
-#include "handles/TimerHandleInterface.hpp"
+#include "SharedInterface.hpp"
+#include "mocks/include/Channel/MockChannelMessageRegistrator.hpp"
+#include "mocks/include/handles/MockBackoffTimerHandle.hpp"
+#include <map>
+#include <string>
+#include <string_view>
 
 namespace mocks
 {
 	class MockShared : public SharedInterface
 	{
 	public:
-		explicit MockShared();
+		explicit MockShared(std::function<uint64_t()> getTimeMs);
 
 		~MockShared() override = default;
 
 	public:
-		::Channel::ChannelMessageRegistratorInterface* GetChannelMessageRegistrator() const override
+		::Channel::ChannelMessageRegistratorInterface* GetChannelMessageRegistrator() override
 		{
 			return this->channelMessageRegistrator.get();
 		}
 
-		::Channel::ChannelNotifier* GetChannelNotifier() const override
+		::Channel::ChannelNotifier* GetChannelNotifier() override
 		{
 			return this->channelNotifier.get();
 		}
 
-		TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) const override;
+		TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) override;
 
 		BackoffTimerHandleInterface* CreateBackoffTimer(
-		  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) const override;
+		  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) override;
+
+		uint64_t GetTimeMs() override
+		{
+			return this->getTimeMs();
+		}
+
+		uint64_t GetTimeUs() override
+		{
+			return GetTimeMs() * 1000;
+		}
+
+		uint64_t GetTimeNs() override
+		{
+			return GetTimeMs() * 1000 * 1000;
+		}
+
+		int64_t GetTimeMsInt64() override
+		{
+			return static_cast<int64_t>(GetTimeMs());
+		}
+
+		int64_t GetTimeUsInt64() override
+		{
+			return static_cast<int64_t>(GetTimeUs());
+		}
+
+		// Methods for testing.
+	public:
+		MockBackoffTimerHandle* GetBackoffTimer(const std::string_view label) const
+		{
+			const auto it = this->backoffTimers.find(std::string(label));
+
+			if (it != this->backoffTimers.end())
+			{
+				return it->second;
+			}
+			else
+			{
+				return nullptr;
+			}
+		}
 
 	private:
+		// Given by argument.
+		const std::function<uint64_t()> getTimeMs;
+		// Others.
 		std::unique_ptr<::Channel::ChannelSocket> channelSocket;
 		std::unique_ptr<mocks::Channel::MockChannelMessageRegistrator> channelMessageRegistrator;
 		std::unique_ptr<::Channel::ChannelNotifier> channelNotifier;
+		std::map<std::string /*label*/, MockBackoffTimerHandle* /*backoffTimer*/> backoffTimers;
 	};
 } // namespace mocks
 

package/worker/mocks/include/RTC/SCTP/association/MockAssociationListener.hpp

@@ -0,0 +1,308 @@
+#ifndef MS_MOCKS_RTC_SCTP_MOCK_ASSOCIATION_LISTENER_HPP
+#define MS_MOCKS_RTC_SCTP_MOCK_ASSOCIATION_LISTENER_HPP
+
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
+#include <deque>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace mocks
+{
+	namespace RTC
+	{
+		namespace SCTP
+		{
+			class MockAssociationListener : public ::RTC::SCTP::AssociationListenerInterface
+			{
+			public:
+				bool OnAssociationSendData(const uint8_t* data, size_t len) override
+				{
+					this->sentPackets.emplace_back(data, data + len);
+
+					return true;
+				}
+
+				void OnAssociationConnecting() override
+				{
+					this->connecting = true;
+				}
+
+				void OnAssociationConnected() override
+				{
+					this->connecting = false;
+					this->connected  = true;
+				}
+
+				void OnAssociationFailed(
+				  ::RTC::SCTP::Types::ErrorKind errorKind, std::string_view errorMessage) override
+				{
+					this->connecting         = false;
+					this->connected          = false;
+					this->failed             = true;
+					this->failedErrorKind    = errorKind;
+					this->failedErrorMessage = errorMessage;
+				}
+
+				void OnAssociationClosed(
+				  ::RTC::SCTP::Types::ErrorKind errorKind, std::string_view errorMessage) override
+				{
+					this->connecting         = false;
+					this->connected          = false;
+					this->closed             = true;
+					this->closedErrorKind    = errorKind;
+					this->closedErrorMessage = errorMessage;
+				}
+
+				void OnAssociationRestarted() override
+				{
+					this->restarted = true;
+				}
+
+				void OnAssociationError(
+				  ::RTC::SCTP::Types::ErrorKind errorKind, std::string_view errorMessage) override
+				{
+					this->connecting          = false;
+					this->connected           = false;
+					this->errored             = true;
+					this->erroredErrorKind    = errorKind;
+					this->erroredErrorMessage = errorMessage;
+				}
+
+				void OnAssociationMessageReceived(::RTC::SCTP::Message message) override
+				{
+					this->receivedMessages.emplace_back(std::move(message));
+				}
+
+				void OnAssociationStreamsResetPerformed(std::span<const uint16_t> /*outboundStreamIds*/) override
+				{
+					// TODO: Do something here for tests.
+				}
+
+				void OnAssociationStreamsResetFailed(
+				  std::span<const uint16_t> /*outboundStreamIds*/, std::string_view /*errorMessage*/) override
+				{
+					// TODO: Do something here for tests.
+				}
+
+				void OnAssociationInboundStreamsReset(std::span<const uint16_t> /*inboundStreamIds*/) override
+				{
+					// TODO: Do something here for tests.
+				}
+
+				void OnAssociationStreamBufferedAmountLow(uint16_t streamId) override
+				{
+					++this->onStreamBufferedAmountLowCalls[streamId];
+				}
+
+				void OnAssociationTotalBufferedAmountLow() override
+				{
+					++this->onTotalBufferedAmountLowCalls;
+				}
+
+				bool OnAssociationIsTransportReadyForSctp() override
+				{
+					return this->transportReady;
+				}
+
+				void OnAssociationLifecycleMessageFullySent(uint64_t lifecycleId) override
+				{
+					this->onAssociationLifecycleMessageFullySentCalls.insert(lifecycleId);
+				}
+
+				void OnAssociationLifecycleMessageExpired(uint64_t lifecycleId, bool maybeDelivered) override
+				{
+					this->onAssociationLifecycleMessageExpiredCalls[lifecycleId] = maybeDelivered;
+				}
+
+				void OnAssociationLifecycleMessageDelivered(uint64_t lifecycleId) override
+				{
+					this->onAssociationLifecycleMessageDeliveredCalls.insert(lifecycleId);
+				}
+
+				void OnAssociationLifecycleMessageEnd(uint64_t lifecycleId) override
+				{
+					this->onAssociationLifecycleMessageEndCalls.insert(lifecycleId);
+				}
+
+				// Methods for testing.
+			public:
+				bool IsConnecting() const
+				{
+					return this->connecting;
+				}
+
+				bool IsConnected() const
+				{
+					return this->connected;
+				}
+
+				bool HasRestarted() const
+				{
+					return this->restarted;
+				}
+
+				bool HasFailed() const
+				{
+					return this->failed;
+				}
+
+				::RTC::SCTP::Types::ErrorKind GetFailedErrorKind() const
+				{
+					return this->failedErrorKind;
+				}
+
+				const std::string& GetFailedErrorMessage() const
+				{
+					return this->failedErrorMessage;
+				}
+
+				bool IsClosed() const
+				{
+					return this->closed;
+				}
+
+				::RTC::SCTP::Types::ErrorKind GetClosedErrorKind() const
+				{
+					return this->closedErrorKind;
+				}
+
+				const std::string& GetClosedErrorMessage() const
+				{
+					return this->closedErrorMessage;
+				}
+
+				bool HasErrored() const
+				{
+					return this->errored;
+				}
+
+				::RTC::SCTP::Types::ErrorKind GetErroredErrorKind() const
+				{
+					return this->erroredErrorKind;
+				}
+
+				const std::string& GetErroredErrorMessage() const
+				{
+					return this->erroredErrorMessage;
+				}
+
+				bool HasOnStreamBufferedAmountLowBeenCalledWithStreamId(uint64_t streamId) const
+				{
+					return this->onStreamBufferedAmountLowCalls.contains(streamId);
+				}
+
+				size_t CountOnStreamBufferedAmountLowCallsWithStreamId(uint64_t streamId) const
+				{
+					if (!this->onStreamBufferedAmountLowCalls.contains(streamId))
+					{
+						return 0;
+					}
+
+					return this->onStreamBufferedAmountLowCalls.at(streamId);
+				}
+
+				size_t CountOnTotalBufferedAmountLowCalls() const
+				{
+					return this->onTotalBufferedAmountLowCalls;
+				}
+
+				bool HasSentPackets() const
+				{
+					return !this->sentPackets.empty();
+				}
+
+				bool HasReceivedMessages() const
+				{
+					return !this->receivedMessages.empty();
+				}
+
+				std::vector<uint8_t> ConsumeFirstSentPacket()
+				{
+					if (this->sentPackets.empty())
+					{
+						return {};
+					}
+
+					const auto packet = std::move(this->sentPackets.front());
+
+					this->sentPackets.pop_front();
+
+					return packet;
+				}
+
+				std::optional<::RTC::SCTP::Message> ConsumeFirstReceivedMessage()
+				{
+					if (this->receivedMessages.empty())
+					{
+						return std::nullopt;
+					}
+
+					auto message = std::move(this->receivedMessages.front());
+
+					this->receivedMessages.pop_front();
+
+					return message;
+				}
+
+				bool IsTransportReady() const
+				{
+					return this->transportReady;
+				}
+
+				bool HasOnAssociationLifecycleMessageFullySentBeenCalledWithLifecycleId(uint64_t lifecycleId) const
+				{
+					return this->onAssociationLifecycleMessageFullySentCalls.contains(lifecycleId);
+				}
+
+				bool HasOnAssociationLifecycleMessageExpiredSentBeenCalledWithLifecycleId(
+				  uint64_t lifecycleId, bool maybeDelivered) const
+				{
+					if (!this->onAssociationLifecycleMessageExpiredCalls.contains(lifecycleId))
+					{
+						return false;
+					}
+
+					return this->onAssociationLifecycleMessageExpiredCalls.at(lifecycleId) == maybeDelivered;
+				}
+
+				bool HasOnAssociationLifecycleMessageDeliveredBeenCalledWithLifecycleId(uint64_t lifecycleId) const
+				{
+					return this->onAssociationLifecycleMessageDeliveredCalls.contains(lifecycleId);
+				}
+
+				bool HasOnAssociationLifecycleMessageEndBeenCalledWithLifecycleId(uint64_t lifecycleId) const
+				{
+					return this->onAssociationLifecycleMessageEndCalls.contains(lifecycleId);
+				}
+
+			private:
+				// Observable state for tests.
+				bool connecting{ false };
+				bool connected{ false };
+				bool restarted{ false };
+				bool failed{ false };
+				::RTC::SCTP::Types::ErrorKind failedErrorKind;
+				std::string failedErrorMessage;
+				bool closed{ false };
+				::RTC::SCTP::Types::ErrorKind closedErrorKind;
+				std::string closedErrorMessage;
+				bool errored{ false };
+				::RTC::SCTP::Types::ErrorKind erroredErrorKind;
+				std::string erroredErrorMessage;
+				std::map<uint16_t /*streamId*/, size_t /*count*/> onStreamBufferedAmountLowCalls;
+				size_t onTotalBufferedAmountLowCalls{ 0 };
+				std::deque<std::vector<uint8_t>> sentPackets;
+				std::deque<::RTC::SCTP::Message> receivedMessages;
+				bool transportReady{ true };
+				std::set<uint64_t /*lifecycleId*/> onAssociationLifecycleMessageFullySentCalls;
+				std::map<uint64_t /*lifecycleId*/, bool /*maybeDelivered*/> onAssociationLifecycleMessageExpiredCalls;
+				std::set<uint64_t /*lifecycleId*/> onAssociationLifecycleMessageDeliveredCalls;
+				std::set<uint64_t /*lifecycleId*/> onAssociationLifecycleMessageEndCalls;
+			};
+		} // namespace SCTP
+	} // namespace RTC
+} // namespace mocks
+
+#endif

package/worker/mocks/include/RTC/SCTP/association/MockTransmissionControlBlockContext.hpp

@@ -0,0 +1,183 @@
+#ifndef MS_MOCKS_RTC_SCTP_MOCK_TRANSMISSION_CONTROL_BLOCK_HPP
+#define MS_MOCKS_RTC_SCTP_MOCK_TRANSMISSION_CONTROL_BLOCK_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/association/TransmissionControlBlockContextInterface.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
+#include "RTC/SCTP/public/SctpOptions.hpp"
+#include "mocks/include/mockTypes.hpp"
+#include <queue>
+#include <stdexcept>
+#include <string>
+
+namespace mocks
+{
+	namespace RTC
+	{
+		namespace SCTP
+		{
+			class MockTransmissionControlBlockContext
+			  : public ::RTC::SCTP::TransmissionControlBlockContextInterface
+			{
+			public:
+				using GetCurrentRtoMsAction = std::function<uint64_t()>;
+
+			public:
+				explicit MockTransmissionControlBlockContext(
+				  ::RTC::SCTP::AssociationListenerInterface& associationListener,
+				  const ::RTC::SCTP::SctpOptions& sctpOptions)
+				  : associationListener(associationListener), sctpOptions(sctpOptions)
+				{
+				}
+
+			public:
+				bool IsAssociationEstablished() const override
+				{
+					return this->associationEstablished;
+				}
+
+				uint32_t GetLocalInitialTsn() const override
+				{
+					// TODO: Implement this.
+					return 0;
+				}
+
+				uint32_t GetRemoteInitialTsn() const override
+				{
+					// TODO: Implement this.
+					return 0;
+				}
+
+				void ObserveRttMs(uint64_t rttMs) override
+				{
+					this->observeRttMsCallCount++;
+				}
+
+				uint64_t GetCurrentRtoMs() const override
+				{
+					if (!this->getCurrentRtoMsOnceActions.empty())
+					{
+						auto action = std::move(this->getCurrentRtoMsOnceActions.front());
+
+						this->getCurrentRtoMsOnceActions.pop();
+
+						return action();
+					}
+					else
+					{
+						return 0;
+					}
+				}
+
+				bool IncrementTxErrorCounter(std::string_view /*reason*/) override
+				{
+					this->incrementTxErrorCounterCallCount++;
+
+					return false;
+				}
+
+				void ClearTxErrorCounter() override
+				{
+					this->incrementTxErrorCounterCallCount = 0;
+				}
+
+				bool HasTooManyTxErrors() const override
+				{
+					// TODO: Implement this.
+					return false;
+				}
+
+				std::unique_ptr<::RTC::SCTP::Packet> CreatePacket() const override;
+
+				bool SendPacket(::RTC::SCTP::Packet* packet) override;
+
+				// Methods for testing.
+			public:
+				void SetAssociationEstablished(bool associationEstablished)
+				{
+					this->associationEstablished = associationEstablished;
+				}
+
+				/**
+				 * @remarks
+				 * - Must be called before expecting calls to `ObserveRttMs()`.
+				 */
+				MockTransmissionControlBlockContext& ExpectObserveRttMsCalledTimes(size_t times)
+				{
+					this->observeRttMsCallCount         = 0;
+					this->expectedObserveRttMsCallCount = times;
+
+					return *this;
+				}
+
+				/**
+				 * @remarks
+				 * - Must be called before expecting calls to `IncrementTxErrorCounter()`.
+				 */
+				MockTransmissionControlBlockContext& ExpectIncrementTxErrorCounterCalledTimes(size_t times)
+				{
+					this->incrementTxErrorCounterCallCount         = 0;
+					this->expectedIncrementTxErrorCounterCallCount = times;
+
+					return *this;
+				}
+
+				MockTransmissionControlBlockContext& WillGetCurrentRtoMsOnce(GetCurrentRtoMsAction action)
+				{
+					this->getCurrentRtoMsOnceActions.push(std::move(action));
+
+					return *this;
+				}
+
+				mocks::VerificationResult VerifyExpectations() const
+				{
+					if (
+					  this->expectedObserveRttMsCallCount.has_value() &&
+					  this->observeRttMsCallCount != this->expectedObserveRttMsCallCount.value())
+					{
+						return { .ok           = false,
+							       .errorMessage = "ObserveRttMs() call count mismatch [expected:" +
+							                       std::to_string(this->expectedObserveRttMsCallCount.value()) +
+							                       ", got:" + std::to_string(this->observeRttMsCallCount) + "]" };
+					}
+
+					if (
+					  this->expectedIncrementTxErrorCounterCallCount.has_value() &&
+					  this->incrementTxErrorCounterCallCount !=
+					    this->expectedIncrementTxErrorCounterCallCount.value())
+					{
+						return { .ok = false,
+							       .errorMessage =
+							         "IncrementTxErrorCounter() call count mismatch [expected:" +
+							         std::to_string(this->expectedIncrementTxErrorCounterCallCount.value()) +
+							         ", got:" + std::to_string(this->incrementTxErrorCounterCallCount) + "]" };
+					}
+
+					return { .ok = true, .errorMessage = "" };
+				}
+
+			private:
+				// Passed by argument.
+				::RTC::SCTP::AssociationListenerInterface& associationListener;
+				const ::RTC::SCTP::SctpOptions sctpOptions;
+
+				// ObserveRttMs().
+				size_t observeRttMsCallCount{ 0 };
+				std::optional<size_t> expectedObserveRttMsCallCount;
+
+				// GetCurrentRtoMs().
+				mutable std::queue<GetCurrentRtoMsAction> getCurrentRtoMsOnceActions;
+
+				// IncrementTxErrorCounter().
+				size_t incrementTxErrorCounterCallCount{ 0 };
+				std::optional<size_t> expectedIncrementTxErrorCounterCallCount;
+
+				// Others.
+				bool associationEstablished{ false };
+			};
+		} // namespace SCTP
+	} // namespace RTC
+} // namespace mocks
+
+#endif