Remove validations since server does that.

Author: marcin-cebo

pubnub-kotlin/pubnub-kotlin-api/src/jvmMain/kotlin/com/pubnub/api/PubNub.kt

@@ -774,9 +774,6 @@ actual interface PubNub : StatusEmitter, EventEmitter {
      *              - Values outside the valid range are automatically adjusted to 1000 with a warning log
      * @param offset Zero-based starting index for pagination. Returns occupants starting from this position in the list. Must be >= 0.
      *              - Default: null (no offset)
-     *              - Requires limit > 0 (throws [PubNubException] with [PubNubError.HERE_NOW_OFFSET_REQUIRES_LIMIT_HIGHER_THAN_0] if limit is 0)
-     *              - Use with limit to paginate through large user lists
-     *              - Throws [PubNubException] with [PubNubError.HERE_NOW_OFFSET_OUT_OF_RANGE] if negative
      */
     actual fun hereNow(
         channels: List<String>,

pubnub-kotlin/pubnub-kotlin-core-api/src/commonMain/kotlin/com/pubnub/api/PubNubError.kt

@@ -240,16 +240,6 @@ enum class PubNubError(private val code: Int, val message: String) {
         "Channel and/or ChannelGroup contains empty string which is not allowed.",
     ),
 
-    HERE_NOW_OFFSET_OUT_OF_RANGE(
-        182,
-        "HereNow offset is out of range. Valid range is 0 to infinity.",
-    ),
-
-    HERE_NOW_OFFSET_REQUIRES_LIMIT_HIGHER_THAN_0(
-        183,
-        "offset requires limit > 0",
-    )
-
     ;
 
     override fun toString(): String {

pubnub-kotlin/pubnub-kotlin-impl/src/integrationTest/kotlin/com/pubnub/api/integration/PresenceIntegrationTests.kt

@@ -1,6 +1,7 @@
 package com.pubnub.api.integration
 
 import com.pubnub.api.PubNub
+import com.pubnub.api.PubNubException
 import com.pubnub.api.callbacks.SubscribeCallback
 import com.pubnub.api.enums.PNHeartbeatNotificationOptions
 import com.pubnub.api.enums.PNStatusCategory
@@ -24,7 +25,6 @@ import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Test
-import org.junit.jupiter.api.Assertions.assertNotNull
 import org.junit.jupiter.api.Timeout
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
@@ -741,4 +741,62 @@ class PresenceIntegrationTests : BaseIntegrationTest() {
             channelGroup = channelGroupName,
         ).sync()
     }
+
+    @Test
+    fun testHereNowWithLimitAbove1000andBelow0() {
+        val limitAboveMax = 2000
+        val totalClientsCount = 5
+        val expectedChannel = randomChannel()
+
+        val clients =
+            mutableListOf(pubnub).apply {
+                addAll(generateSequence { createPubNub {} }.take(totalClientsCount - 1).toList())
+            }
+
+        clients.forEach {
+            it.subscribeNonBlocking(expectedChannel)
+        }
+        Thread.sleep(2000)
+
+        // This should not throw a client-side validation error
+        // Server will validate the limit and respond accordingly
+        pubnub.hereNow(
+            channels = listOf(expectedChannel),
+            includeUUIDs = true,
+            limit = limitAboveMax,
+        ).asyncRetry { result ->
+            assertTrue(result.isFailure)
+            result.onFailure { exception: PubNubException ->
+                assertTrue(exception.message!!.contains("Cannot return more than 1000 uuids at a time"))
+            }
+        }
+    }
+
+    @Test
+    fun testHereNowWithLimitBelow0() {
+        val limitBelow0 = -1
+        val totalClientsCount = 5
+        val expectedChannel = randomChannel()
+
+        val clients =
+            mutableListOf(pubnub).apply {
+                addAll(generateSequence { createPubNub {} }.take(totalClientsCount - 1).toList())
+            }
+
+        clients.forEach {
+            it.subscribeNonBlocking(expectedChannel)
+        }
+        Thread.sleep(2000)
+
+        pubnub.hereNow(
+            channels = listOf(expectedChannel),
+            includeUUIDs = true,
+            limit = limitBelow0,
+        ).asyncRetry { result ->
+            assertTrue(result.isFailure)
+            result.onFailure { exception: PubNubException ->
+                assertTrue(exception.message!!.contains("Limit must be greater than or equal to 0"))
+            }
+        }
+    }
 }

pubnub-kotlin/pubnub-kotlin-impl/src/main/kotlin/com/pubnub/internal/endpoints/presence/HereNowEndpoint.kt

@@ -1,8 +1,6 @@
 package com.pubnub.internal.endpoints.presence
 
 import com.google.gson.JsonElement
-import com.pubnub.api.PubNubError
-import com.pubnub.api.PubNubException
 import com.pubnub.api.endpoints.presence.HereNow
 import com.pubnub.api.enums.PNOperationType
 import com.pubnub.api.logging.LogMessage
@@ -22,8 +20,6 @@ import retrofit2.Response
 
 private const val MAX_CHANNEL_OCCUPANTS_LIMIT = 1000
 
-private const val MIN_CHANNEL_OCCUPANTS_LIMIT = 0
-
 /**
  * @see [PubNubImpl.hereNow]
  */
@@ -37,19 +33,6 @@ class HereNowEndpoint internal constructor(
     override val offset: Int? = null,
 ) : EndpointCore<Envelope<JsonElement>, PNHereNowResult>(pubnub), HereNow {
     private val log: PNLogger = LoggerManager.instance.getLogger(pubnub.logConfig, this::class.java)
-    internal val effectiveLimit: Int = if (limit in MIN_CHANNEL_OCCUPANTS_LIMIT..MAX_CHANNEL_OCCUPANTS_LIMIT) {
-        limit
-    } else {
-        log.warn(
-            LogMessage(
-                LogMessageContent.Text(
-                    "Valid range is $MIN_CHANNEL_OCCUPANTS_LIMIT to $MAX_CHANNEL_OCCUPANTS_LIMIT. " +
-                        "Shrinking limit to $MAX_CHANNEL_OCCUPANTS_LIMIT."
-                )
-            )
-        )
-        MAX_CHANNEL_OCCUPANTS_LIMIT
-    }
 
     private fun isGlobalHereNow() = channels.isEmpty() && channelGroups.isEmpty()
 
@@ -58,13 +41,6 @@ class HereNowEndpoint internal constructor(
     override fun getAffectedChannelGroups() = channelGroups
 
     override fun doWork(queryParams: HashMap<String, String>): Call<Envelope<JsonElement>> {
-        if (offset != null && offset < 0) {
-            throw PubNubException(PubNubError.HERE_NOW_OFFSET_OUT_OF_RANGE)
-        }
-        if (offset != null && effectiveLimit == 0) {
-            throw PubNubException(PubNubError.HERE_NOW_OFFSET_REQUIRES_LIMIT_HIGHER_THAN_0)
-        }
-
         log.debug(
             LogMessage(
                 message = LogMessageContent.Object(
@@ -73,7 +49,7 @@ class HereNowEndpoint internal constructor(
                         "channelGroups" to channelGroups,
                         "includeState" to includeState,
                         "includeUUIDs" to includeUUIDs,
-                        "limit" to effectiveLimit,
+                        "limit" to limit,
                         "offset" to (offset?.toString() ?: "null"),
                         "isGlobalHereNow" to isGlobalHereNow(),
                     ),
@@ -196,7 +172,7 @@ class HereNowEndpoint internal constructor(
         if (channelGroups.isNotEmpty()) {
             queryParams["channel-group"] = channelGroups.toCsv()
         }
-        queryParams["limit"] = effectiveLimit.toString()
+        queryParams["limit"] = limit.toString()
         offset?.let { queryParams["offset"] = it.toString() }
     }
 }

pubnub-kotlin/pubnub-kotlin-impl/src/test/kotlin/com/pubnub/internal/endpoints/presence/HereNowEndpointTest.kt

@@ -40,19 +40,7 @@ class HereNowEndpointTest : BaseTest() {
     }
 
     @Test
-    fun testHereNowLimitMinimumBoundary() {
-        // Test minimum valid limit value
-        val hereNow = pubnub.hereNow(
-            channels = listOf("test-channel"),
-            includeUUIDs = true,
-            limit = 1
-        )
-        assertNotNull(hereNow)
-        assertEquals(1, (hereNow as HereNowEndpoint).limit)
-    }
-
-    @Test
-    fun testHereNowLimitMaximumBoundary() {
+    fun testHereNowAcceptsDefaultLimitValue() {
         // Test maximum valid limit value
         val hereNow = pubnub.hereNow(
             channels = listOf("test-channel"),
@@ -64,33 +52,9 @@ class HereNowEndpointTest : BaseTest() {
     }
 
     @Test
-    fun testHereNowLimitAboveMaximumShrinks() {
-        // Test that limit > 1000 automatically shrinks to 1000
-        val endpoint = HereNowEndpoint(
-            pubnub = pubnub,
-            channels = listOf("test-channel"),
-            includeUUIDs = true,
-            limit = 1500
-        )
-        assertNotNull(endpoint)
-        // When limit is out of range, endpoint stores the original value
-        assertEquals(1500, endpoint.limit)
-        assertEquals(1000, endpoint.effectiveLimit)
-    }
-
-    @Test
-    fun testHereNowLimitNegativeUsesDefault() {
-        // Test that negative limit uses default of 1000
-        val endpoint = HereNowEndpoint(
-            pubnub = pubnub,
-            channels = listOf("test-channel"),
-            includeUUIDs = true,
-            limit = -5
-        )
-        assertNotNull(endpoint)
-        // When limit is out of range, the original value is stored
-        assertEquals(-5, endpoint.limit)
-        assertEquals(1000, endpoint.effectiveLimit)
+    fun testHereNowAcceptsLimitBeyondAdvisedMaximum() {
+        val hereNow = pubnub.hereNow(channels = listOf("test"), limit = 5000)
+        assertEquals(5000, (hereNow as HereNowEndpoint).limit) // Passes to server for validation
     }
 
     @Test
@@ -104,17 +68,4 @@ class HereNowEndpointTest : BaseTest() {
         assertNotNull(hereNow)
         assertEquals(1000000, (hereNow as HereNowEndpoint).offset)
     }
-
-    @Test
-    fun testHereNowStartFromLargeNegativeAccepted() {
-        // Test that large negative offset is accepted at creation time
-        // (validation happens during execution in doWork())
-        val hereNow = pubnub.hereNow(
-            channels = listOf("test-channel"),
-            includeUUIDs = true,
-            offset = -100
-        )
-        assertNotNull(hereNow)
-        assertEquals(-100, (hereNow as HereNowEndpoint).offset)
-    }
 }