tests/libxrpl/server/InfoSub.cpp

#include <xrpl/server/InfoSub.h>
 
#include <gtest/gtest.h>
 
#include <cstddef>
#include <limits>
 
using namespace xrpl;
 
// The per-connection subscription cap is enforced by the pure predicate
// exceedsSubscriptionCap(current, additional). Testing it directly (rather than
// by subscribing the real cap through a WebSocket, which would exceed the frame
// limit and drop the connection before the check runs) lets the boundary be
// asserted exactly.
TEST(InfoSubSubscriptionCap, boundary)
{
    constexpr std::size_t cap = kMaxSubscriptionsPerConnection;
 
    // Empty connection: anything up to the cap is admitted, cap+1 is not.
    EXPECT_FALSE(exceedsSubscriptionCap(0, 0));
    EXPECT_FALSE(exceedsSubscriptionCap(0, cap));
    EXPECT_TRUE(exceedsSubscriptionCap(0, cap + 1));
 
    // Exactly at the cap: zero more is fine, one more is rejected.
    EXPECT_FALSE(exceedsSubscriptionCap(cap, 0));
    EXPECT_TRUE(exceedsSubscriptionCap(cap, 1));
 
    // One below the cap: exactly one more reaches the cap; two exceed it.
    EXPECT_FALSE(exceedsSubscriptionCap(cap - 1, 1));
    EXPECT_TRUE(exceedsSubscriptionCap(cap - 1, 2));
}
 
TEST(InfoSubSubscriptionCap, no_overflow)
{
    constexpr std::size_t cap = kMaxSubscriptionsPerConnection;
    constexpr std::size_t max = std::numeric_limits<std::size_t>::max();
 
    // current + additional must not wrap: a huge additional is rejected even
    // when current is 0 (the additional > cap term guards the subtraction).
    EXPECT_TRUE(exceedsSubscriptionCap(0, max));
    EXPECT_TRUE(exceedsSubscriptionCap(cap, max));
}
 
TEST(InfoSubSubscriptionCap, explicit_cap)
{
    // A configured override is honored: the boundary tracks the passed cap, not
    // the built-in default. This is the seam doSubscribe uses to enforce a
    // per-connection cap set via [max_subscriptions_per_connection].
    constexpr std::size_t cap = 5;
 
    EXPECT_FALSE(exceedsSubscriptionCap(0, cap, cap));
    EXPECT_TRUE(exceedsSubscriptionCap(0, cap + 1, cap));
    EXPECT_FALSE(exceedsSubscriptionCap(cap, 0, cap));
    EXPECT_TRUE(exceedsSubscriptionCap(cap, 1, cap));
    EXPECT_FALSE(exceedsSubscriptionCap(cap - 1, 1, cap));
    EXPECT_TRUE(exceedsSubscriptionCap(cap - 1, 2, cap));
 
    // The overflow guard still holds with a small explicit cap.
    EXPECT_TRUE(exceedsSubscriptionCap(0, std::numeric_limits<std::size_t>::max(), cap));
}