Merge branch 'main' into feat-661-uuid

Signed-off-by: ff137 <[email protected]>

Author: ff137

.github/workflows/test.yml

@@ -4,17 +4,23 @@ on:
   push:
     branches:
       - main
+      - "release/**"
+      - "dev/**"
   pull_request:
     branches:
       - "**"
 
 jobs:
   test:
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    env:
+      NATS_SERVER_VERSION: ${{ matrix.nats_version }}
     strategy:
+      fail-fast: false
       matrix:
-        os: [ubuntu-latest]
         python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        nats_version: ["v2.10.26", "v2.11.0", "main"]
 
     steps:
       - name: Check out repository
@@ -28,6 +34,7 @@ jobs:
       - name: Install dependencies
         run: |
           pip install pipenv
+          pip install certifi
           pipenv install --dev
           bash ./scripts/install_nats.sh
 

nats/aio/client.py

@@ -18,6 +18,7 @@
 import base64
 import ipaddress
 import logging
+import re
 import ssl
 import string
 import time
@@ -59,7 +60,7 @@
 )
 from .transport import TcpTransport, Transport, WebSocketTransport
 
-__version__ = "2.9.0"
+__version__ = "2.10.0"
 __lang__ = "python3"
 _logger = logging.getLogger(__name__)
 PROTOCOL = 1
@@ -134,39 +135,77 @@ def __init__(self, server_version: str) -> None:
         self._major_version: Optional[int] = None
         self._minor_version: Optional[int] = None
         self._patch_version: Optional[int] = None
+        self._prerelease_version: Optional[str] = None
+        self._build_version: Optional[str] = None
         self._dev_version: Optional[str] = None
 
-    # TODO(@orsinium): use cached_property
     def parse_version(self) -> None:
-        v = (self._server_version).split("-")
-        if len(v) > 1:
-            self._dev_version = v[1]
-        tokens = v[0].split(".")
-        n = len(tokens)
-        if n > 1:
-            self._major_version = int(tokens[0])
-        if n > 2:
-            self._minor_version = int(tokens[1])
-        if n > 3:
-            self._patch_version = int(tokens[2])
+        # https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+        _SEMVER_REGEX = r"""
+            ^
+            (?P<major>0|[1-9]\d*)
+            \.
+            (?P<minor>0|[1-9]\d*)
+            \.
+            (?P<patch>0|[1-9]\d*)
+            (?:-(?P<prerelease>
+                (?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)
+                (?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*
+            ))?
+            (?:\+(?P<buildmetadata>
+                [0-9a-zA-Z-]+
+                (?:\.[0-9a-zA-Z-]+)*
+            ))?
+            $
+        """
+        _REGEX = re.compile(_SEMVER_REGEX, re.VERBOSE)
+        match = _REGEX.match(self._server_version)
+        if match is None:
+            raise ValueError(
+                f"{self._server_version} is not a valid Semantic Version"
+            )
+        matches = match.groupdict()
+        self._major_version = int(matches["major"])
+        self._minor_version = int(matches["minor"])
+        self._patch_version = int(matches["patch"])
+        self._prerelease_version = matches["prerelease"] or ""
+        self._build_version = matches["buildmetadata"] or ""
+        if self._build_version:
+            self._dev_version = '+'.join([
+                self._prerelease_version, self._build_version
+            ])
+        else:
+            self._dev_version = self._prerelease_version
 
     @property
     def major(self) -> int:
         if not self._major_version:
             self.parse_version()
-        return self._major_version or 0
+        return self._major_version
 
     @property
     def minor(self) -> int:
         if not self._minor_version:
             self.parse_version()
-        return self._minor_version or 0
+        return self._minor_version
 
     @property
     def patch(self) -> int:
         if not self._patch_version:
             self.parse_version()
-        return self._patch_version or 0
+        return self._patch_version
+
+    @property
+    def prerelease(self) -> int:
+        if not self._prerelease_version:
+            self.parse_version()
+        return self._prerelease_version
+
+    @property
+    def build(self) -> int:
+        if not self._build_version:
+            self.parse_version()
+        return self._build_version
 
     @property
     def dev(self) -> str:

scripts/install_nats.sh

@@ -2,7 +2,7 @@
 
 set -e
 
-export DEFAULT_NATS_SERVER_VERSION=v2.10.17
+export DEFAULT_NATS_SERVER_VERSION=v2.10.26
 
 export NATS_SERVER_VERSION="${NATS_SERVER_VERSION:=$DEFAULT_NATS_SERVER_VERSION}"
 

setup.py

@@ -4,7 +4,7 @@
 # These are here for GitHub's dependency graph and help with setuptools support in some environments.
 setup(
     name="nats-py",
-    version="2.9.0",
+    version="2.10.0",
     license="Apache 2 License",
     extras_require={
         "nkeys": ["nkeys"],

tests/test_client.py

@@ -10,7 +10,7 @@
 import nats
 import nats.errors
 import pytest
-from nats.aio.client import Client as NATS, __version__
+from nats.aio.client import Client as NATS, ServerVersion, __version__
 from nats.json_util import JsonUtil as json
 from tests.utils import (
     ClusteringDiscoveryAuthTestCase,
@@ -67,6 +67,79 @@ def test_default_connect_command_with_name(self):
 
         self.assertEqual(expected.encode(), got)
 
+    def test_semver_parsing(self):
+        # Test common versions for the NATS Server.
+        v = ServerVersion("2.10.26")
+        self.assertEqual(2, v.major)
+        self.assertEqual(10, v.minor)
+        self.assertEqual(26, v.patch)
+
+        v = ServerVersion("2.10.26+foo")
+        self.assertEqual(2, v.major)
+        self.assertEqual(10, v.minor)
+        self.assertEqual(26, v.patch)
+        self.assertEqual("foo", v.build)
+
+        v = ServerVersion("2.11.1-RC.1")
+        self.assertEqual(2, v.major)
+        self.assertEqual(11, v.minor)
+        self.assertEqual(1, v.patch)
+        self.assertEqual("RC.1", v.prerelease)
+
+        v = ServerVersion("2.11.1-RC.1+syn1")
+        self.assertEqual(2, v.major)
+        self.assertEqual(11, v.minor)
+        self.assertEqual(1, v.patch)
+        self.assertEqual("RC.1", v.prerelease)
+        self.assertEqual("syn1", v.build)
+
+        v = ServerVersion("2.11.1-beta+syn2")
+        self.assertEqual(2, v.major)
+        self.assertEqual(11, v.minor)
+        self.assertEqual(1, v.patch)
+        self.assertEqual("beta", v.prerelease)
+        self.assertEqual("syn2", v.build)
+        self.assertEqual("beta+syn2", v.dev)
+
+        v = ServerVersion("2.11.1-dev")
+        self.assertEqual(2, v.major)
+        self.assertEqual(11, v.minor)
+        self.assertEqual(1, v.patch)
+        self.assertEqual("dev", v.prerelease)
+        self.assertEqual("", v.build)
+        self.assertEqual("dev", v.dev)
+
+        with self.assertRaises(ValueError):
+            v = ServerVersion("aaaaaaaaa")
+            v.major
+
+        with self.assertRaises(ValueError):
+            v = ServerVersion("2.11.1!dev")
+            v.major
+
+        with self.assertRaises(ValueError):
+            v = ServerVersion("")
+            v.major
+
+        # Check that some common server versions do not panic.
+        versions = [
+            "2.2.2", "2.2.2", "2.2.2", "2.2.2-prerelease+meta", "2.2.2+meta",
+            "2.2.2+meta-valid", "2.2.2-alpha", "2.2.2-beta",
+            "2.2.2-alpha.beta", "2.2.2-alpha.beta.1", "2.2.2-alpha.1",
+            "2.2.2-alpha0.valid", "2.2.2-alpha.0valid",
+            "2.2.2-alpha-a.b-c-somethinglong+build.1-aef.1-its-okay",
+            "2.2.2-rc.1+build.1", "2.2.2-rc.1+build.123", "2.2.2-RC.1+build.1",
+            "2.2.2-RC.1+build.123", "2.2.2-rc.1", "2.2.2-RC.1",
+            "2.2.2-RC.1+foo", "2.2.2-beta", "2.2.2-DEV-SNAPSHOT",
+            "2.2.2-SNAPSHOT-123", "2.2.2", "2.2.2", "2.2.2",
+            "2.2.2+build.1848", "2.2.2-alpha.1227", "2.2.2-alpha+beta"
+        ]
+        for version in versions:
+            v = ServerVersion(version)
+            self.assertEqual(v.major, 2)
+            self.assertEqual(v.minor, 2)
+            self.assertTrue(v.patch, 2)
+
 
 class ClientTest(SingleServerTestCase):
 
@@ -87,6 +160,15 @@ async def test_default_connect(self):
         self.assertTrue(nc.is_closed)
         self.assertFalse(nc.is_connected)
 
+    @async_test
+    async def test_connected_server_version(self):
+        nc = await nats.connect()
+        version = nc.connected_server_version
+        self.assertEqual(version.major, 2)
+        self.assertTrue(version.minor is not None)
+        self.assertTrue(version.patch is not None)
+        await nc.close()
+
     @async_test
     async def test_default_module_connect(self):
         nc = await nats.connect()

tests/test_js.py

@@ -2622,8 +2622,9 @@ async def error_handler(e):
         # Check remaining messages in the stream state.
         status = await kv.status()
         # NOTE: Behavior changed here from v2.10.9 => v2.10.10
-        # assert status.values == 2
-        assert status.values == 1
+        # then changed again around v2.10.26.
+        assert status.values == 2
+        # assert status.values == 1
 
         entry = await kv.get("hello")
         assert "hello" == entry.key
@@ -2638,13 +2639,13 @@ async def error_handler(e):
         assert 1 == entry.revision
 
         status = await kv.status()
-        assert status.values == 1
+        assert status.values == 2
 
         for i in range(100, 200):
             await kv.put(f"hello.{i}", b"Hello JS KV!")
 
         status = await kv.status()
-        assert status.values == 101
+        assert status.values == 102
 
         with pytest.raises(NotFoundError):
             await kv.get("hello.5")