uptime-kuma-api2 2.1.0__tar.gz

uptime_kuma_api2-2.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Paolo Barone
+Copyright (c) 2023 Lucas Held (original work)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

uptime_kuma_api2-2.1.0/PKG-INFO

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: uptime-kuma-api2
+Version: 2.1.0
+Summary: A python wrapper for the Uptime Kuma WebSocket API (v2 support)
+Home-page: https://github.com/pbarone/uptime-kuma-api-v2
+Author: Paolo Barone
+Author-email: pbarone@users.noreply.github.com
+License: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.7, <4
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-socketio[client]>=5.0.0
+Requires-Dist: packaging
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# uptime-kuma-api-v2
+
+A wrapper for the Uptime Kuma Socket.IO API — with full v2 support
+---
+
+> **Fork notice:** This is an actively maintained fork of [lucasheld/uptime-kuma-api](https://github.com/lucasheld/uptime-kuma-api), which appears to be unmaintained (last release: 2023, open PRs unanswered). This fork adds full Uptime Kuma v2.x support while maintaining backward compatibility with v1.x. Original work by [Lucas Held](https://github.com/lucasheld) — thank you for building the foundation.
+
+uptime-kuma-api-v2 is a Python wrapper for the [Uptime Kuma](https://github.com/louislam/uptime-kuma) Socket.IO API.
+
+This package was originally developed to configure Uptime Kuma with Ansible. The original Ansible collection can be found at https://github.com/lucasheld/ansible-uptime-kuma.
+
+Python version 3.7+ is required.
+
+Supported Uptime Kuma versions:
+
+| Uptime Kuma     | uptime-kuma-api |
+|-----------------|-----------------|
+| 2.0.0 - 2.4.0   | 2.0.0 - 2.1.0   |
+| 1.21.3 - 1.23.2 | 1.0.0 - 1.2.1   |
+| 1.17.0 - 1.21.2 | 0.1.0 - 0.13.0  |
+
+Installation
+---
+uptime-kuma-api2 is available on the [Python Package Index (PyPI)](https://pypi.org/project/uptime-kuma-api2/).
+
+You can install it using pip:
+
+```
+pip install uptime-kuma-api2
+```
+
+Documentation
+---
+The API Reference is available on [Read the Docs](https://uptime-kuma-api.readthedocs.io).
+
+Example
+---
+Once you have installed the python package, you can use it to communicate with an Uptime Kuma instance.
+
+To do so, import `UptimeKumaApi` from the library and specify the Uptime Kuma server url (e.g. 'http://127.0.0.1:3001'), username and password to initialize the connection.
+
+```python
+>>> from uptime_kuma_api import UptimeKumaApi, MonitorType
+>>> api = UptimeKumaApi('INSERT_URL')
+>>> api.login('INSERT_USERNAME', 'INSERT_PASSWORD')
+```
+
+Now you can call one of the existing methods of the instance. For example create a new monitor:
+
+```python
+>>> result = api.add_monitor(type=MonitorType.HTTP, name="Google", url="https://google.com")
+>>> print(result)
+{'msg': 'Added Successfully.', 'monitorId': 1}
+```
+
+At the end, the connection to the API must be disconnected so that the program does not block.
+
+```python
+>>> api.disconnect()
+```
+
+With a context manager, the disconnect method is called automatically:
+
+```python
+from uptime_kuma_api import UptimeKumaApi
+
+with UptimeKumaApi('INSERT_URL') as api:
+    api.login('INSERT_USERNAME', 'INSERT_PASSWORD')
+    api.add_monitor(
+        type=MonitorType.HTTP,
+        name="Google",
+        url="https://google.com"
+    )
+```
+
+MonitorBuilder
+---
+For complex monitor configurations, use the fluent `MonitorBuilder`:
+
+```python
+from uptime_kuma_api import UptimeKumaApi, MonitorType, MonitorBuilder
+
+with UptimeKumaApi('INSERT_URL') as api:
+    api.login('INSERT_USERNAME', 'INSERT_PASSWORD')
+    
+    config = (
+        MonitorBuilder()
+        .type(MonitorType.HTTP)
+        .name("My Monitor")
+        .url("https://example.com")
+        .interval(60)
+        .conditions([
+            {"type": "expression", "variable": "response_status", "operator": "==", "value": "200", "andOr": ""}
+        ])
+        .build()
+    )
+    result = api.add_monitor(**config)
+    print(result)
+```
+
+New in v2.1.0
+---
+- **New monitor types**: RabbitMQ, SNMP, SMTP, System Service
+- **New notification providers**: Nextcloud Talk, Brevo, Evolution API
+- **MonitorBuilder**: Fluent builder pattern for monitor configuration
+- **Logger support**: Pass a custom logger for Socket.IO debugging
+- **v2-only parameters**: Automatic version gating ensures backward compatibility with v1.x
+
+Testing
+---
+Unit tests cover all v2 features and can be run without a live server:
+
+```
+pip install pytest
+pytest tests/ -v
+```
+
+Test files:
+
+| File | Coverage |
+|------|----------|
+| `tests/test_monitor_types_v2.py` | New monitor types (RABBITMQ, SNMP, SMTP, SYSTEM_SERVICE) |
+| `tests/test_monitor_params_v2.py` | v2 monitor parameters, version gating, validation |
+| `tests/test_status_page_v2.py` | Status page analytics replacement, password removal, new fields |
+| `tests/test_notification_v2.py` | Nextcloud Talk, Brevo, Evolution API providers |
+| `tests/test_logger.py` | Logger parameter type validation |
+| `tests/test_monitor_builder.py` | MonitorBuilder fluent API |

uptime_kuma_api2-2.1.0/README.md

@@ -0,0 +1,127 @@
+# uptime-kuma-api-v2
+
+A wrapper for the Uptime Kuma Socket.IO API — with full v2 support
+---
+
+> **Fork notice:** This is an actively maintained fork of [lucasheld/uptime-kuma-api](https://github.com/lucasheld/uptime-kuma-api), which appears to be unmaintained (last release: 2023, open PRs unanswered). This fork adds full Uptime Kuma v2.x support while maintaining backward compatibility with v1.x. Original work by [Lucas Held](https://github.com/lucasheld) — thank you for building the foundation.
+
+uptime-kuma-api-v2 is a Python wrapper for the [Uptime Kuma](https://github.com/louislam/uptime-kuma) Socket.IO API.
+
+This package was originally developed to configure Uptime Kuma with Ansible. The original Ansible collection can be found at https://github.com/lucasheld/ansible-uptime-kuma.
+
+Python version 3.7+ is required.
+
+Supported Uptime Kuma versions:
+
+| Uptime Kuma     | uptime-kuma-api |
+|-----------------|-----------------|
+| 2.0.0 - 2.4.0   | 2.0.0 - 2.1.0   |
+| 1.21.3 - 1.23.2 | 1.0.0 - 1.2.1   |
+| 1.17.0 - 1.21.2 | 0.1.0 - 0.13.0  |
+
+Installation
+---
+uptime-kuma-api2 is available on the [Python Package Index (PyPI)](https://pypi.org/project/uptime-kuma-api2/).
+
+You can install it using pip:
+
+```
+pip install uptime-kuma-api2
+```
+
+Documentation
+---
+The API Reference is available on [Read the Docs](https://uptime-kuma-api.readthedocs.io).
+
+Example
+---
+Once you have installed the python package, you can use it to communicate with an Uptime Kuma instance.
+
+To do so, import `UptimeKumaApi` from the library and specify the Uptime Kuma server url (e.g. 'http://127.0.0.1:3001'), username and password to initialize the connection.
+
+```python
+>>> from uptime_kuma_api import UptimeKumaApi, MonitorType
+>>> api = UptimeKumaApi('INSERT_URL')
+>>> api.login('INSERT_USERNAME', 'INSERT_PASSWORD')
+```
+
+Now you can call one of the existing methods of the instance. For example create a new monitor:
+
+```python
+>>> result = api.add_monitor(type=MonitorType.HTTP, name="Google", url="https://google.com")
+>>> print(result)
+{'msg': 'Added Successfully.', 'monitorId': 1}
+```
+
+At the end, the connection to the API must be disconnected so that the program does not block.
+
+```python
+>>> api.disconnect()
+```
+
+With a context manager, the disconnect method is called automatically:
+
+```python
+from uptime_kuma_api import UptimeKumaApi
+
+with UptimeKumaApi('INSERT_URL') as api:
+    api.login('INSERT_USERNAME', 'INSERT_PASSWORD')
+    api.add_monitor(
+        type=MonitorType.HTTP,
+        name="Google",
+        url="https://google.com"
+    )
+```
+
+MonitorBuilder
+---
+For complex monitor configurations, use the fluent `MonitorBuilder`:
+
+```python
+from uptime_kuma_api import UptimeKumaApi, MonitorType, MonitorBuilder
+
+with UptimeKumaApi('INSERT_URL') as api:
+    api.login('INSERT_USERNAME', 'INSERT_PASSWORD')
+    
+    config = (
+        MonitorBuilder()
+        .type(MonitorType.HTTP)
+        .name("My Monitor")
+        .url("https://example.com")
+        .interval(60)
+        .conditions([
+            {"type": "expression", "variable": "response_status", "operator": "==", "value": "200", "andOr": ""}
+        ])
+        .build()
+    )
+    result = api.add_monitor(**config)
+    print(result)
+```
+
+New in v2.1.0
+---
+- **New monitor types**: RabbitMQ, SNMP, SMTP, System Service
+- **New notification providers**: Nextcloud Talk, Brevo, Evolution API
+- **MonitorBuilder**: Fluent builder pattern for monitor configuration
+- **Logger support**: Pass a custom logger for Socket.IO debugging
+- **v2-only parameters**: Automatic version gating ensures backward compatibility with v1.x
+
+Testing
+---
+Unit tests cover all v2 features and can be run without a live server:
+
+```
+pip install pytest
+pytest tests/ -v
+```
+
+Test files:
+
+| File | Coverage |
+|------|----------|
+| `tests/test_monitor_types_v2.py` | New monitor types (RABBITMQ, SNMP, SMTP, SYSTEM_SERVICE) |
+| `tests/test_monitor_params_v2.py` | v2 monitor parameters, version gating, validation |
+| `tests/test_status_page_v2.py` | Status page analytics replacement, password removal, new fields |
+| `tests/test_notification_v2.py` | Nextcloud Talk, Brevo, Evolution API providers |
+| `tests/test_logger.py` | Logger parameter type validation |
+| `tests/test_monitor_builder.py` | MonitorBuilder fluent API |

uptime_kuma_api2-2.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

uptime_kuma_api2-2.1.0/setup.py

@@ -0,0 +1,55 @@
+from setuptools import setup
+from codecs import open
+import os
+import sys
+
+# "setup.py publish" shortcut.
+if sys.argv[-1] == "publish":
+    os.system("rm dist/*")
+    os.system("python setup.py sdist")
+    os.system("twine upload dist/*")
+    sys.exit()
+
+info = {}
+here = os.path.abspath(os.path.dirname(__file__))
+with open(os.path.join(here, "uptime_kuma_api", "__version__.py"), "r", "utf-8") as f:
+    exec(f.read(), info)
+
+with open("README.md", "r", "utf-8") as f:
+    readme = f.read()
+
+setup(
+    name="uptime-kuma-api2",
+    version=info["__version__"],
+    description="A python wrapper for the Uptime Kuma WebSocket API (v2 support)",
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    url="https://github.com/pbarone/uptime-kuma-api-v2",
+    author=info["__author__"],
+    author_email="pbarone@users.noreply.github.com",
+    license=info["__license__"],
+    packages=["uptime_kuma_api"],
+    python_requires=">=3.7, <4",
+    install_requires=[
+        "python-socketio[client]>=5.0.0",
+        "packaging"
+    ],
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Environment :: Web Environment",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Natural Language :: English",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3 :: Only",
+        "Topic :: Internet :: WWW/HTTP",
+        "Topic :: Software Development :: Libraries"
+    ]
+)

uptime_kuma_api2-2.1.0/tests/test_2fa.py

@@ -0,0 +1,56 @@
+import unittest
+from urllib import parse
+
+import pyotp
+
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+def parse_secret(uri):
+    query = parse.urlsplit(uri).query
+    params = dict(parse.parse_qsl(query))
+    return params["secret"]
+
+
+def generate_token(secret):
+    totp = pyotp.TOTP(secret)
+    return totp.now()
+
+
+class Test2FA(UptimeKumaTestCase):
+    def test_2fa(self):
+        # check 2fa is disabled
+        r = self.api.twofa_status()
+        self.assertEqual(r["status"], False)
+
+        # prepare 2fa
+        r = self.api.prepare_2fa(self.password)
+        uri = r["uri"]
+        self.assertTrue(uri.startswith("otpauth://totp/"))
+        secret = parse_secret(uri)
+
+        # verify token
+        token = generate_token(secret)
+        r = self.api.verify_token(token, self.password)
+        self.assertEqual(r["valid"], True)
+
+        # save 2fa
+        r = self.api.save_2fa(self.password)
+        self.assertEqual(r["msg"], "2FA Enabled.")
+
+        # check 2fa is enabled
+        r = self.api.twofa_status()
+        self.assertEqual(r["status"], True)
+
+        # relogin using the totp token
+        self.api.logout()
+        token = generate_token(secret)
+        self.api.login(self.username, self.password, token)
+
+        # disable 2fa
+        r = self.api.disable_2fa(self.password)
+        self.assertEqual(r["msg"], "2FA Disabled.")
+
+
+if __name__ == '__main__':
+    unittest.main()

uptime_kuma_api2-2.1.0/tests/test_api_key.py

@@ -0,0 +1,59 @@
+import unittest
+
+from uptime_kuma_api import UptimeKumaException
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+class TestApiKey(UptimeKumaTestCase):
+    def test_api_key(self):
+        # get empty list to make sure that future accesses will also work
+        self.api.get_api_keys()
+
+        expected = {
+            "name": "name 1",
+            "expires": "2023-03-30 12:20:00",
+            "active": True
+        }
+
+        # add api key
+        r = self.api.add_api_key(**expected)
+        self.assertEqual(r["msg"], "Added Successfully.")
+        api_key_id = r["keyID"]
+
+        # get api key
+        api_key = self.api.get_api_key(api_key_id)
+        self.compare(api_key, expected)
+
+        # get api keys
+        api_keys = self.api.get_api_keys()
+        api_key = self.find_by_id(api_keys, api_key_id)
+        self.assertIsNotNone(api_key)
+        self.compare(api_key, expected)
+
+        # disable api key
+        r = self.api.disable_api_key(api_key_id)
+        self.assertEqual(r["msg"], "Disabled Successfully.")
+        api_key = self.api.get_api_key(api_key_id)
+        expected["active"] = False
+        self.compare(api_key, expected)
+
+        # enable api key
+        r = self.api.enable_api_key(api_key_id)
+        self.assertEqual(r["msg"], "Enabled Successfully")
+        api_key = self.api.get_api_key(api_key_id)
+        expected["active"] = True
+        self.compare(api_key, expected)
+
+        # delete api key
+        r = self.api.delete_api_key(api_key_id)
+        self.assertEqual(r["msg"], "Deleted Successfully.")
+        with self.assertRaises(UptimeKumaException):
+            self.api.get_api_key(api_key_id)
+
+    def test_delete_not_existing_api_key(self):
+        with self.assertRaises(UptimeKumaException):
+            self.api.delete_api_key(42)
+
+
+if __name__ == '__main__':
+    unittest.main()

uptime_kuma_api2-2.1.0/tests/test_avg_ping.py

@@ -0,0 +1,13 @@
+import unittest
+
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+class TestAvgPing(UptimeKumaTestCase):
+    def test_avg_ping(self):
+        self.add_monitor()
+        self.api.avg_ping()
+
+
+if __name__ == '__main__':
+    unittest.main()

uptime_kuma_api2-2.1.0/tests/test_clear.py

@@ -0,0 +1,20 @@
+import unittest
+
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+class TestClear(UptimeKumaTestCase):
+    def test_clear_events(self):
+        monitor_id = self.add_monitor()
+        self.api.clear_events(monitor_id)
+
+    def test_clear_heartbeats(self):
+        monitor_id = self.add_monitor()
+        self.api.clear_heartbeats(monitor_id)
+
+    def test_clear_statistics(self):
+        self.api.clear_statistics()
+
+
+if __name__ == '__main__':
+    unittest.main()

uptime_kuma_api2-2.1.0/tests/test_database.py

@@ -0,0 +1,16 @@
+import unittest
+
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+class TestDatabase(UptimeKumaTestCase):
+    def test_get_database_size(self):
+        r = self.api.get_database_size()
+        self.assertIn("size", r)
+
+    def test_shrink_database(self):
+        self.api.shrink_database()
+
+
+if __name__ == '__main__':
+    unittest.main()

uptime_kuma_api2-2.1.0/tests/test_docker_host.py

@@ -0,0 +1,60 @@
+import unittest
+from packaging.version import parse as parse_version
+
+from uptime_kuma_api import DockerType, UptimeKumaException
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+class TestDockerHost(UptimeKumaTestCase):
+    def test_docker_host(self):
+        # get empty list to make sure that future accesses will also work
+        self.api.get_docker_hosts()
+
+        expected_docker_host = {
+            "name": "name 1",
+            "dockerType": DockerType.SOCKET,
+            "dockerDaemon": "/var/run/docker.sock"
+        }
+
+        # test docker host
+        if parse_version(self.api.version) != parse_version("1.23.0"):
+            # test_docker_host does not work in 1.23.0 (https://github.com/louislam/uptime-kuma/issues/3605)
+            with self.assertRaisesRegex(UptimeKumaException, r'connect ENOENT /var/run/docker.sock'):
+                self.api.test_docker_host(**expected_docker_host)
+
+        # add docker host
+        r = self.api.add_docker_host(**expected_docker_host)
+        self.assertEqual(r["msg"], "Saved")
+        docker_host_id = r["id"]
+
+        # get docker host
+        docker_host = self.api.get_docker_host(docker_host_id)
+        self.compare(docker_host, expected_docker_host)
+
+        # get docker hosts
+        docker_hosts = self.api.get_docker_hosts()
+        self.assertTrue(type(docker_hosts[0]["dockerType"]) == DockerType)
+        docker_host = self.find_by_id(docker_hosts, docker_host_id)
+        self.assertIsNotNone(docker_host)
+        self.compare(docker_host, expected_docker_host)
+
+        # edit docker host
+        r = self.api.edit_docker_host(docker_host_id, name="name 2")
+        self.assertEqual(r["msg"], "Saved")
+        docker_host = self.api.get_docker_host(docker_host_id)
+        expected_docker_host["name"] = "name 2"
+        self.compare(docker_host, expected_docker_host)
+
+        # delete docker host
+        r = self.api.delete_docker_host(docker_host_id)
+        self.assertEqual(r["msg"], "Deleted")
+        with self.assertRaises(UptimeKumaException):
+            self.api.get_docker_host(docker_host_id)
+
+    def test_delete_not_existing_docker_host(self):
+        with self.assertRaises(UptimeKumaException):
+            self.api.delete_docker_host(42)
+
+
+if __name__ == '__main__':
+    unittest.main()

uptime_kuma_api2-2.1.0/tests/test_game_list.py

@@ -0,0 +1,13 @@
+import unittest
+
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+class TestGameList(UptimeKumaTestCase):
+    def test_game_list(self):
+        game_list = self.api.get_game_list()
+        self.assertTrue("keys" in game_list[0])
+
+
+if __name__ == '__main__':
+    unittest.main()

uptime_kuma_api2-2.1.0/tests/test_heartbeat.py

@@ -0,0 +1,20 @@
+import unittest
+
+from uptime_kuma_api import MonitorStatus
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+class TestHeartbeat(UptimeKumaTestCase):
+    def test_get_heartbeats(self):
+        self.add_monitor()
+        r = self.api.get_heartbeats()
+        self.assertTrue(type(list(r.values())[0][0]["status"]) == MonitorStatus)
+
+    def test_get_important_heartbeats(self):
+        self.add_monitor()
+        r = self.api.get_important_heartbeats()
+        self.assertTrue(type(list(r.values())[0][0]["status"]) == MonitorStatus)
+
+
+if __name__ == '__main__':
+    unittest.main()

uptime_kuma_api2-2.1.0/tests/test_helper_methods.py

@@ -0,0 +1,15 @@
+import unittest
+
+from uptime_kuma_api import MonitorStatus
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+class TestHelperMethods(UptimeKumaTestCase):
+    def test_monitor_status(self):
+        monitor_id = self.add_monitor()
+        status = self.api.get_monitor_status(monitor_id)
+        self.assertTrue(type(status) == MonitorStatus)
+
+
+if __name__ == '__main__':
+    unittest.main()

uptime_kuma_api2-2.1.0/tests/test_info.py

@@ -0,0 +1,25 @@
+import unittest
+
+from uptime_kuma_api import UptimeKumaApi
+from uptime_kuma_test_case import UptimeKumaTestCase
+
+
+class TestInfo(UptimeKumaTestCase):
+    def test_info(self):
+        info = self.api.info()
+        self.assertIn("version", info)
+        self.assertIn("latestVersion", info)
+
+    def test_info_with_version(self):
+        # If wait_events is set to 0, the first info event is normally used.
+        # The info event handler needs to drop this first event without a version.
+        self.api.logout()
+        self.api.disconnect()
+        self.api = UptimeKumaApi(self.url, wait_events=0)
+        self.api.login(self.username, self.password)
+        info = self.api.info()
+        self.assertIn("version", info)
+
+
+if __name__ == '__main__':
+    unittest.main()