Skip to content

armgit / zulip

Public Imported from GitHub
0

Zulip server and web application. Open-source team chat that helps teams stay productive and focused.

tests: Move bot storage and config tests to test_embedded_bot_system.py.

sathwikshetty339e855fb707e1
diff --git a/zerver/tests/test_embedded_bot_system.py b/zerver/tests/test_embedded_bot_system.py
index 75e4daa4420..79b7eb123f0 100644
--- a/zerver/tests/test_embedded_bot_system.py
+++ b/zerver/tests/test_embedded_bot_system.py
@@ -1,11 +1,22 @@
from unittest.mock import patch
import orjson
+from django.conf import settings
+from django.test import override_settings
from typing_extensions import override
-from zerver.lib.bot_lib import EmbeddedBotQuitError
+from zerver.actions.create_user import do_create_user
+from zerver.lib.bot_config import ConfigError, load_bot_config_template, set_bot_config
+from zerver.lib.bot_lib import (
+ EmbeddedBotEmptyRecipientsListError,
+ EmbeddedBotHandler,
+ EmbeddedBotQuitError,
+ StateHandler,
+)
+from zerver.lib.bot_storage import StateError
from zerver.lib.display_recipient import get_display_recipient
from zerver.lib.test_classes import ZulipTestCase
+from zerver.lib.validator import check_string
from zerver.models import UserProfile
from zerver.models.bots import get_service_profile
from zerver.models.realms import get_realm
@@ -122,3 +133,258 @@ class TestEmbeddedBotFailures(ZulipTestCase):
m.output[0],
f"ERROR:root:Error: User {bot_profile.id} has bot with invalid embedded bot service invalid",
)
+
+
+class TestServiceBotStateHandler(ZulipTestCase):
+ @override
+ def setUp(self) -> None:
+ super().setUp()
+ self.user_profile = self.example_user("othello")
+ self.bot_profile = do_create_user(
+ password="test",
+ realm=get_realm("zulip"),
+ full_name="EmbeddedBo1",
+ bot_type=UserProfile.EMBEDDED_BOT,
+ bot_owner=self.user_profile,
+ acting_user=None,
+ )
+ self.second_bot_profile = do_create_user(
+ password="test",
+ realm=get_realm("zulip"),
+ full_name="EmbeddedBot2",
+ bot_type=UserProfile.EMBEDDED_BOT,
+ bot_owner=self.user_profile,
+ acting_user=None,
+ )
+
+ def test_basic_storage_and_retrieval(self) -> None:
+ storage = StateHandler(self.bot_profile)
+ storage.put("some key", "some value")
+ storage.put("some other key", "some other value")
+ self.assertEqual(storage.get("some key"), "some value")
+ self.assertEqual(storage.get("some other key"), "some other value")
+ self.assertTrue(storage.contains("some key"))
+ self.assertFalse(storage.contains("nonexistent key"))
+ self.assertRaisesMessage(
+ StateError, "Key does not exist.", lambda: storage.get("nonexistent key")
+ )
+ storage.put("some key", "a new value")
+ self.assertEqual(storage.get("some key"), "a new value")
+ second_storage = StateHandler(self.second_bot_profile)
+ self.assertRaises(StateError, lambda: second_storage.get("some key"))
+ second_storage.put("some key", "yet another value")
+ self.assertEqual(storage.get("some key"), "a new value")
+ self.assertEqual(second_storage.get("some key"), "yet another value")
+
+ def test_marshaling(self) -> None:
+ storage = StateHandler(self.bot_profile)
+ serializable_obj = {"foo": "bar", "baz": [42, "cux"]}
+ storage.put("some key", serializable_obj)
+ self.assertEqual(storage.get("some key"), serializable_obj)
+
+ # Reduce maximal storage size for faster test string construction.
+ @override_settings(USER_STATE_SIZE_LIMIT=100)
+ def test_storage_limit(self) -> None:
+ storage = StateHandler(self.bot_profile)
+
+ # Disable marshaling for storing a string whose size is
+ # equivalent to the size of the stored object.
+ storage.marshal = lambda obj: check_string("obj", obj)
+ storage.demarshal = lambda obj: obj
+
+ key = "capacity-filling entry"
+ storage.put(key, "x" * (settings.USER_STATE_SIZE_LIMIT - len(key)))
+
+ with self.assertRaisesMessage(
+ StateError,
+ "Request exceeds storage limit by 32 characters. The limit is 100 characters.",
+ ):
+ storage.put("too much data", "a few bits too long")
+
+ second_storage = StateHandler(self.second_bot_profile)
+ second_storage.put("another big entry", "x" * (settings.USER_STATE_SIZE_LIMIT - 40))
+ second_storage.put("normal entry", "abcd")
+
+ def test_entry_removal(self) -> None:
+ storage = StateHandler(self.bot_profile)
+ storage.put("some key", "some value")
+ storage.put("another key", "some value")
+ self.assertTrue(storage.contains("some key"))
+ self.assertTrue(storage.contains("another key"))
+ storage.remove("some key")
+ self.assertFalse(storage.contains("some key"))
+ self.assertTrue(storage.contains("another key"))
+ self.assertRaises(StateError, lambda: storage.remove("some key"))
+
+ def test_bot_storage_restrictions(self) -> None:
+ bot_storage_url = "/api/v1/bot_storage"
+ result = self.api_put(self.user_profile, bot_storage_url, {"storage": "{}"})
+ self.assert_json_error(result, "Must be a bot user")
+ result = self.api_get(self.user_profile, bot_storage_url)
+ self.assert_json_error(result, "Must be a bot user")
+ result = self.api_delete(self.user_profile, bot_storage_url)
+ self.assert_json_error(result, "Must be a bot user")
+
+ def test_bot_storage_endpoint(self) -> None:
+ bot_storage_url = "/api/v1/bot_storage"
+
+ # Store some data.
+ initial_dict = {"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
+ params = {
+ "storage": orjson.dumps(initial_dict).decode(),
+ }
+ result = self.api_put(self.bot_profile, bot_storage_url, params)
+ self.assert_json_success(result)
+
+ # Assert the stored data for some keys.
+ params = {
+ "keys": orjson.dumps(["key 1", "key 3"]).decode(),
+ }
+ result = self.api_get(self.bot_profile, bot_storage_url, params)
+ response_dict = self.assert_json_success(result)
+ self.assertEqual(response_dict["storage"], {"key 3": "value 3", "key 1": "value 1"})
+
+ # Assert the stored data for all keys.
+ result = self.api_get(self.bot_profile, bot_storage_url)
+ response_dict = self.assert_json_success(result)
+ self.assertEqual(response_dict["storage"], initial_dict)
+
+ # Store some more data; update an entry and store a new entry
+ dict_update = {"key 1": "new value", "key 4": "value 4"}
+ params = {
+ "storage": orjson.dumps(dict_update).decode(),
+ }
+ result = self.api_put(self.bot_profile, bot_storage_url, params)
+ self.assert_json_success(result)
+
+ # Assert the data was updated.
+ updated_dict = initial_dict.copy()
+ updated_dict.update(dict_update)
+ result = self.api_get(self.bot_profile, bot_storage_url)
+ response_dict = self.assert_json_success(result)
+ self.assertEqual(response_dict["storage"], updated_dict)
+
+ # Assert errors on invalid requests.
+ invalid_params = {
+ "keys": ["This is a list, but should be a serialized string."],
+ }
+ result = self.api_get(self.bot_profile, bot_storage_url, invalid_params)
+ self.assert_json_error(result, "keys is not valid JSON")
+
+ params = {
+ "keys": orjson.dumps(["key 1", "nonexistent key"]).decode(),
+ }
+ result = self.api_get(self.bot_profile, bot_storage_url, params)
+ self.assert_json_error(result, "Key does not exist.")
+
+ params = {
+ "storage": orjson.dumps({"foo": [1, 2, 3]}).decode(),
+ }
+ result = self.api_put(self.bot_profile, bot_storage_url, params)
+ self.assert_json_error(result, 'storage["foo"] is not a string')
+
+ # Remove some entries.
+ keys_to_remove = ["key 1", "key 2"]
+ params = {
+ "keys": orjson.dumps(keys_to_remove).decode(),
+ }
+ result = self.api_delete(self.bot_profile, bot_storage_url, params)
+ self.assert_json_success(result)
+
+ # Assert the entries were removed.
+ for key in keys_to_remove:
+ updated_dict.pop(key)
+ result = self.api_get(self.bot_profile, bot_storage_url)
+ response_dict = self.assert_json_success(result)
+ self.assertEqual(response_dict["storage"], updated_dict)
+
+ # Try to remove an existing and a nonexistent key.
+ params = {
+ "keys": orjson.dumps(["key 3", "nonexistent key"]).decode(),
+ }
+ result = self.api_delete(self.bot_profile, bot_storage_url, params)
+ self.assert_json_error(result, "Key does not exist.")
+
+ # Assert an error has been thrown and no entries were removed.
+ result = self.api_get(self.bot_profile, bot_storage_url)
+ response_dict = self.assert_json_success(result)
+ self.assertEqual(response_dict["storage"], updated_dict)
+
+ # Remove the entire storage.
+ result = self.api_delete(self.bot_profile, bot_storage_url)
+ self.assert_json_success(result)
+
+ # Assert the entire storage has been removed.
+ result = self.api_get(self.bot_profile, bot_storage_url)
+ response_dict = self.assert_json_success(result)
+ self.assertEqual(response_dict["storage"], {})
+
+
+class TestServiceBotConfigHandler(ZulipTestCase):
+ @override
+ def setUp(self) -> None:
+ super().setUp()
+ self.user_profile = self.example_user("othello")
+ self.bot_profile = self.create_test_bot(
+ "embedded",
+ self.user_profile,
+ full_name="Embedded bot",
+ bot_type=UserProfile.EMBEDDED_BOT,
+ service_name="helloworld",
+ )
+ self.bot_handler = EmbeddedBotHandler(self.bot_profile)
+
+ def test_basic_storage_and_retrieval(self) -> None:
+ with self.assertRaises(ConfigError):
+ self.bot_handler.get_config_info("foo")
+
+ self.assertEqual(self.bot_handler.get_config_info("foo", optional=True), {})
+
+ config_dict = {"entry 1": "value 1", "entry 2": "value 2"}
+ for key, value in config_dict.items():
+ set_bot_config(self.bot_profile, key, value)
+ self.assertEqual(self.bot_handler.get_config_info("foo"), config_dict)
+
+ config_update = {"entry 2": "new value", "entry 3": "value 3"}
+ for key, value in config_update.items():
+ set_bot_config(self.bot_profile, key, value)
+ config_dict.update(config_update)
+ self.assertEqual(self.bot_handler.get_config_info("foo"), config_dict)
+
+ @override_settings(BOT_CONFIG_SIZE_LIMIT=100)
+ def test_config_entry_limit(self) -> None:
+ set_bot_config(self.bot_profile, "some key", "x" * (settings.BOT_CONFIG_SIZE_LIMIT - 8))
+ self.assertRaisesMessage(
+ ConfigError,
+ "Cannot store configuration. Request would require 101 characters. "
+ "The current configuration size limit is 100 characters.",
+ lambda: set_bot_config(
+ self.bot_profile, "some key", "x" * (settings.BOT_CONFIG_SIZE_LIMIT - 8 + 1)
+ ),
+ )
+ set_bot_config(self.bot_profile, "some key", "x" * (settings.BOT_CONFIG_SIZE_LIMIT - 20))
+ set_bot_config(self.bot_profile, "another key", "x")
+ self.assertRaisesMessage(
+ ConfigError,
+ "Cannot store configuration. Request would require 116 characters. "
+ "The current configuration size limit is 100 characters.",
+ lambda: set_bot_config(self.bot_profile, "yet another key", "x"),
+ )
+
+ def test_load_bot_config_template(self) -> None:
+ bot_config = load_bot_config_template("giphy")
+ self.assertTrue(isinstance(bot_config, dict))
+ self.assert_length(bot_config, 1)
+
+ def test_load_bot_config_template_for_bot_without_config_data(self) -> None:
+ bot_config = load_bot_config_template("converter")
+ self.assertTrue(isinstance(bot_config, dict))
+ self.assert_length(bot_config, 0)
+
+ def test_bot_send_pm_with_empty_recipients_list(self) -> None:
+ with self.assertRaisesRegex(
+ EmbeddedBotEmptyRecipientsListError, "Message must have recipients!"
+ ):
+ self.bot_handler.send_message(message={"type": "private", "to": []})
diff --git a/zerver/tests/test_service_bot_system.py b/zerver/tests/test_service_bot_system.py
index 885c075858c..070a38ee371 100644
--- a/zerver/tests/test_service_bot_system.py
+++ b/zerver/tests/test_service_bot_system.py
@@ -3,20 +3,13 @@ from functools import wraps
from typing import Any, Concatenate
from unittest import mock
-import orjson
import responses
-from django.conf import settings
-from django.test import override_settings
from typing_extensions import ParamSpec, override
from zerver.actions.create_user import do_create_user
from zerver.actions.message_send import get_service_bot_events
-from zerver.lib.bot_config import ConfigError, load_bot_config_template, set_bot_config
-from zerver.lib.bot_lib import EmbeddedBotEmptyRecipientsListError, EmbeddedBotHandler, StateHandler
-from zerver.lib.bot_storage import StateError
from zerver.lib.test_classes import ZulipTestCase
from zerver.lib.test_helpers import mock_queue_publish
-from zerver.lib.validator import check_string
from zerver.models import Recipient, UserProfile
from zerver.models.messages import UserMessage
from zerver.models.realms import get_realm
@@ -175,261 +168,6 @@ class TestServiceBotBasics(ZulipTestCase):
)
-class TestServiceBotStateHandler(ZulipTestCase):
- @override
- def setUp(self) -> None:
- super().setUp()
- self.user_profile = self.example_user("othello")
- self.bot_profile = do_create_user(
- password="test",
- realm=get_realm("zulip"),
- full_name="EmbeddedBo1",
- bot_type=UserProfile.EMBEDDED_BOT,
- bot_owner=self.user_profile,
- acting_user=None,
- )
- self.second_bot_profile = do_create_user(
- password="test",
- realm=get_realm("zulip"),
- full_name="EmbeddedBot2",
- bot_type=UserProfile.EMBEDDED_BOT,
- bot_owner=self.user_profile,
- acting_user=None,
- )
-
- def test_basic_storage_and_retrieval(self) -> None:
- storage = StateHandler(self.bot_profile)
- storage.put("some key", "some value")
- storage.put("some other key", "some other value")
- self.assertEqual(storage.get("some key"), "some value")
- self.assertEqual(storage.get("some other key"), "some other value")
- self.assertTrue(storage.contains("some key"))
- self.assertFalse(storage.contains("nonexistent key"))
- self.assertRaisesMessage(
- StateError, "Key does not exist.", lambda: storage.get("nonexistent key")
- )
- storage.put("some key", "a new value")
- self.assertEqual(storage.get("some key"), "a new value")
- second_storage = StateHandler(self.second_bot_profile)
- self.assertRaises(StateError, lambda: second_storage.get("some key"))
- second_storage.put("some key", "yet another value")
- self.assertEqual(storage.get("some key"), "a new value")
- self.assertEqual(second_storage.get("some key"), "yet another value")
-
- def test_marshaling(self) -> None:
- storage = StateHandler(self.bot_profile)
- serializable_obj = {"foo": "bar", "baz": [42, "cux"]}
- storage.put("some key", serializable_obj)
- self.assertEqual(storage.get("some key"), serializable_obj)
-
- # Reduce maximal storage size for faster test string construction.
- @override_settings(USER_STATE_SIZE_LIMIT=100)
- def test_storage_limit(self) -> None:
- storage = StateHandler(self.bot_profile)
-
- # Disable marshaling for storing a string whose size is
- # equivalent to the size of the stored object.
- storage.marshal = lambda obj: check_string("obj", obj)
- storage.demarshal = lambda obj: obj
-
- key = "capacity-filling entry"
- storage.put(key, "x" * (settings.USER_STATE_SIZE_LIMIT - len(key)))
-
- with self.assertRaisesMessage(
- StateError,
- "Request exceeds storage limit by 32 characters. The limit is 100 characters.",
- ):
- storage.put("too much data", "a few bits too long")
-
- second_storage = StateHandler(self.second_bot_profile)
- second_storage.put("another big entry", "x" * (settings.USER_STATE_SIZE_LIMIT - 40))
- second_storage.put("normal entry", "abcd")
-
- def test_entry_removal(self) -> None:
- storage = StateHandler(self.bot_profile)
- storage.put("some key", "some value")
- storage.put("another key", "some value")
- self.assertTrue(storage.contains("some key"))
- self.assertTrue(storage.contains("another key"))
- storage.remove("some key")
- self.assertFalse(storage.contains("some key"))
- self.assertTrue(storage.contains("another key"))
- self.assertRaises(StateError, lambda: storage.remove("some key"))
-
- def test_bot_storage_restrictions(self) -> None:
- bot_storage_url = "/api/v1/bot_storage"
- result = self.api_put(self.user_profile, bot_storage_url, {"storage": "{}"})
- self.assert_json_error(result, "Must be a bot user")
- result = self.api_get(self.user_profile, bot_storage_url)
- self.assert_json_error(result, "Must be a bot user")
- result = self.api_delete(self.user_profile, bot_storage_url)
- self.assert_json_error(result, "Must be a bot user")
-
- def test_bot_storage_endpoint(self) -> None:
- bot_storage_url = "/api/v1/bot_storage"
-
- # Store some data.
- initial_dict = {"key 1": "value 1", "key 2": "value 2", "key 3": "value 3"}
- params = {
- "storage": orjson.dumps(initial_dict).decode(),
- }
- result = self.api_put(self.bot_profile, bot_storage_url, params)
- self.assert_json_success(result)
-
- # Assert the stored data for some keys.
- params = {
- "keys": orjson.dumps(["key 1", "key 3"]).decode(),
- }
- result = self.api_get(self.bot_profile, bot_storage_url, params)
- response_dict = self.assert_json_success(result)
- self.assertEqual(response_dict["storage"], {"key 3": "value 3", "key 1": "value 1"})
-
- # Assert the stored data for all keys.
- result = self.api_get(self.bot_profile, bot_storage_url)
- response_dict = self.assert_json_success(result)
- self.assertEqual(response_dict["storage"], initial_dict)
-
- # Store some more data; update an entry and store a new entry
- dict_update = {"key 1": "new value", "key 4": "value 4"}
- params = {
- "storage": orjson.dumps(dict_update).decode(),
- }
- result = self.api_put(self.bot_profile, bot_storage_url, params)
- self.assert_json_success(result)
-
- # Assert the data was updated.
- updated_dict = initial_dict.copy()
- updated_dict.update(dict_update)
- result = self.api_get(self.bot_profile, bot_storage_url)
- response_dict = self.assert_json_success(result)
- self.assertEqual(response_dict["storage"], updated_dict)
-
- # Assert errors on invalid requests.
- invalid_params = {
- "keys": ["This is a list, but should be a serialized string."],
- }
- result = self.api_get(self.bot_profile, bot_storage_url, invalid_params)
- self.assert_json_error(result, "keys is not valid JSON")
-
- params = {
- "keys": orjson.dumps(["key 1", "nonexistent key"]).decode(),
- }
- result = self.api_get(self.bot_profile, bot_storage_url, params)
- self.assert_json_error(result, "Key does not exist.")
-
- params = {
- "storage": orjson.dumps({"foo": [1, 2, 3]}).decode(),
- }
- result = self.api_put(self.bot_profile, bot_storage_url, params)
- self.assert_json_error(result, 'storage["foo"] is not a string')
-
- # Remove some entries.
- keys_to_remove = ["key 1", "key 2"]
- params = {
- "keys": orjson.dumps(keys_to_remove).decode(),
- }
- result = self.api_delete(self.bot_profile, bot_storage_url, params)
- self.assert_json_success(result)
-
- # Assert the entries were removed.
- for key in keys_to_remove:
- updated_dict.pop(key)
- result = self.api_get(self.bot_profile, bot_storage_url)
- response_dict = self.assert_json_success(result)
- self.assertEqual(response_dict["storage"], updated_dict)
-
- # Try to remove an existing and a nonexistent key.
- params = {
- "keys": orjson.dumps(["key 3", "nonexistent key"]).decode(),
- }
- result = self.api_delete(self.bot_profile, bot_storage_url, params)
- self.assert_json_error(result, "Key does not exist.")
-
- # Assert an error has been thrown and no entries were removed.
- result = self.api_get(self.bot_profile, bot_storage_url)
- response_dict = self.assert_json_success(result)
- self.assertEqual(response_dict["storage"], updated_dict)
-
- # Remove the entire storage.
- result = self.api_delete(self.bot_profile, bot_storage_url)
- self.assert_json_success(result)
-
- # Assert the entire storage has been removed.
- result = self.api_get(self.bot_profile, bot_storage_url)
- response_dict = self.assert_json_success(result)
- self.assertEqual(response_dict["storage"], {})
-
-
-class TestServiceBotConfigHandler(ZulipTestCase):
- @override
- def setUp(self) -> None:
- super().setUp()
- self.user_profile = self.example_user("othello")
- self.bot_profile = self.create_test_bot(
- "embedded",
- self.user_profile,
- full_name="Embedded bot",
- bot_type=UserProfile.EMBEDDED_BOT,
- service_name="helloworld",
- )
- self.bot_handler = EmbeddedBotHandler(self.bot_profile)
-
- def test_basic_storage_and_retrieval(self) -> None:
- with self.assertRaises(ConfigError):
- self.bot_handler.get_config_info("foo")
-
- self.assertEqual(self.bot_handler.get_config_info("foo", optional=True), {})
-
- config_dict = {"entry 1": "value 1", "entry 2": "value 2"}
- for key, value in config_dict.items():
- set_bot_config(self.bot_profile, key, value)
- self.assertEqual(self.bot_handler.get_config_info("foo"), config_dict)
-
- config_update = {"entry 2": "new value", "entry 3": "value 3"}
- for key, value in config_update.items():
- set_bot_config(self.bot_profile, key, value)
- config_dict.update(config_update)
- self.assertEqual(self.bot_handler.get_config_info("foo"), config_dict)
-
- @override_settings(BOT_CONFIG_SIZE_LIMIT=100)
- def test_config_entry_limit(self) -> None:
- set_bot_config(self.bot_profile, "some key", "x" * (settings.BOT_CONFIG_SIZE_LIMIT - 8))
- self.assertRaisesMessage(
- ConfigError,
- "Cannot store configuration. Request would require 101 characters. "
- "The current configuration size limit is 100 characters.",
- lambda: set_bot_config(
- self.bot_profile, "some key", "x" * (settings.BOT_CONFIG_SIZE_LIMIT - 8 + 1)
- ),
- )
- set_bot_config(self.bot_profile, "some key", "x" * (settings.BOT_CONFIG_SIZE_LIMIT - 20))
- set_bot_config(self.bot_profile, "another key", "x")
- self.assertRaisesMessage(
- ConfigError,
- "Cannot store configuration. Request would require 116 characters. "
- "The current configuration size limit is 100 characters.",
- lambda: set_bot_config(self.bot_profile, "yet another key", "x"),
- )
-
- def test_load_bot_config_template(self) -> None:
- bot_config = load_bot_config_template("giphy")
- self.assertTrue(isinstance(bot_config, dict))
- self.assert_length(bot_config, 1)
-
- def test_load_bot_config_template_for_bot_without_config_data(self) -> None:
- bot_config = load_bot_config_template("converter")
- self.assertTrue(isinstance(bot_config, dict))
- self.assert_length(bot_config, 0)
-
- def test_bot_send_pm_with_empty_recipients_list(self) -> None:
- with self.assertRaisesRegex(
- EmbeddedBotEmptyRecipientsListError, "Message must have recipients!"
- ):
- self.bot_handler.send_message(message={"type": "private", "to": []})
-
-
ParamT = ParamSpec("ParamT")