forked from 0xWheatyz/SPARC
Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 agent-company
|
2eabb1d704 |
@@ -1,263 +0,0 @@
|
||||
"""Tests for S3/MinIO storage backend in storage.py.
|
||||
|
||||
Covers issue #1660:
|
||||
- S3StorageBackend read, write, exists, path_for
|
||||
- Error handling: NoSuchKey, generic S3 errors, bucket auto-creation
|
||||
- get_storage_backend() factory function
|
||||
- LocalStorageBackend (basic sanity checks)
|
||||
"""
|
||||
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from SPARC.storage import LocalStorageBackend, S3StorageBackend, get_storage_backend
|
||||
|
||||
|
||||
# ---------- S3StorageBackend ----------
|
||||
|
||||
class TestS3StorageBackend:
|
||||
"""Tests for the S3-compatible storage backend."""
|
||||
|
||||
@pytest.fixture
|
||||
def s3_backend(self):
|
||||
"""Create an S3StorageBackend with a fully mocked boto3 client."""
|
||||
with patch.dict("sys.modules", {"boto3": MagicMock()}):
|
||||
import boto3 as mock_boto
|
||||
mock_s3 = MagicMock()
|
||||
mock_boto.client.return_value = mock_s3
|
||||
mock_s3.head_bucket.return_value = {}
|
||||
|
||||
backend = S3StorageBackend(
|
||||
bucket="test-bucket",
|
||||
endpoint_url="http://minio:9000",
|
||||
access_key="minioadmin",
|
||||
secret_key="minioadmin",
|
||||
)
|
||||
# Expose mock for assertions
|
||||
backend._mock_s3 = mock_s3
|
||||
yield backend
|
||||
|
||||
def test_write_puts_object(self, s3_backend):
|
||||
"""write() calls put_object with correct bucket, key, and body."""
|
||||
s3_backend.write("US-12345678-B2.pdf", b"PDF content here")
|
||||
|
||||
s3_backend._mock_s3.put_object.assert_called_once_with(
|
||||
Bucket="test-bucket",
|
||||
Key="US-12345678-B2.pdf",
|
||||
Body=b"PDF content here",
|
||||
ContentType="application/pdf",
|
||||
)
|
||||
|
||||
def test_read_returns_body(self, s3_backend):
|
||||
"""read() returns the Body content from get_object."""
|
||||
mock_body = MagicMock()
|
||||
mock_body.read.return_value = b"PDF data"
|
||||
s3_backend._mock_s3.get_object.return_value = {"Body": mock_body}
|
||||
|
||||
result = s3_backend.read("US-12345678-B2.pdf")
|
||||
|
||||
assert result == b"PDF data"
|
||||
s3_backend._mock_s3.get_object.assert_called_once_with(
|
||||
Bucket="test-bucket",
|
||||
Key="US-12345678-B2.pdf",
|
||||
)
|
||||
|
||||
def test_read_nosuchkey_raises_file_not_found(self, s3_backend):
|
||||
"""read() raises FileNotFoundError when object does not exist."""
|
||||
# Create a NoSuchKey exception class on the mock
|
||||
nosuchkey = type("NoSuchKey", (Exception,), {})
|
||||
s3_backend._mock_s3.exceptions.NoSuchKey = nosuchkey
|
||||
s3_backend._mock_s3.get_object.side_effect = nosuchkey("not found")
|
||||
|
||||
# Reassign s3 to trigger the except branch
|
||||
s3_backend.s3 = s3_backend._mock_s3
|
||||
|
||||
with pytest.raises(FileNotFoundError, match="S3 object not found"):
|
||||
s3_backend.read("missing.pdf")
|
||||
|
||||
def test_read_generic_404_raises_file_not_found(self, s3_backend):
|
||||
"""read() handles generic 404 errors from S3-compatible APIs."""
|
||||
nosuchkey = type("NoSuchKey", (Exception,), {})
|
||||
s3_backend._mock_s3.exceptions.NoSuchKey = nosuchkey
|
||||
s3_backend.s3 = s3_backend._mock_s3
|
||||
s3_backend.s3.get_object.side_effect = Exception("An error occurred (404)")
|
||||
|
||||
with pytest.raises(FileNotFoundError, match="S3 object not found"):
|
||||
s3_backend.read("missing.pdf")
|
||||
|
||||
def test_read_other_error_re_raises(self, s3_backend):
|
||||
"""read() re-raises non-404 errors."""
|
||||
nosuchkey = type("NoSuchKey", (Exception,), {})
|
||||
s3_backend._mock_s3.exceptions.NoSuchKey = nosuchkey
|
||||
s3_backend.s3 = s3_backend._mock_s3
|
||||
s3_backend.s3.get_object.side_effect = Exception("Internal server error")
|
||||
|
||||
with pytest.raises(Exception, match="Internal server error"):
|
||||
s3_backend.read("some-file.pdf")
|
||||
|
||||
def test_exists_returns_true_for_existing_object(self, s3_backend):
|
||||
"""exists() returns True when head_object succeeds with content."""
|
||||
s3_backend._mock_s3.head_object.return_value = {"ContentLength": 1024}
|
||||
|
||||
assert s3_backend.exists("US-12345678-B2.pdf") is True
|
||||
|
||||
def test_exists_returns_false_for_missing_object(self, s3_backend):
|
||||
"""exists() returns False when head_object raises an exception."""
|
||||
s3_backend._mock_s3.head_object.side_effect = Exception("Not Found")
|
||||
|
||||
assert s3_backend.exists("missing.pdf") is False
|
||||
|
||||
def test_exists_returns_false_for_zero_length(self, s3_backend):
|
||||
"""exists() returns False when object has zero content length."""
|
||||
s3_backend._mock_s3.head_object.return_value = {"ContentLength": 0}
|
||||
|
||||
assert s3_backend.exists("empty.pdf") is False
|
||||
|
||||
def test_path_for_returns_s3_uri(self, s3_backend):
|
||||
"""path_for() returns an s3:// URI."""
|
||||
path = s3_backend.path_for("US-12345678-B2.pdf")
|
||||
|
||||
assert path == "s3://test-bucket/US-12345678-B2.pdf"
|
||||
|
||||
def test_constructor_creates_bucket_if_missing(self):
|
||||
"""Constructor creates the bucket if head_bucket fails."""
|
||||
with patch.dict("sys.modules", {"boto3": MagicMock()}):
|
||||
import boto3 as mock_boto
|
||||
mock_s3 = MagicMock()
|
||||
mock_boto.client.return_value = mock_s3
|
||||
mock_s3.head_bucket.side_effect = Exception("Bucket not found")
|
||||
|
||||
S3StorageBackend(
|
||||
bucket="new-bucket",
|
||||
endpoint_url="http://minio:9000",
|
||||
access_key="admin",
|
||||
secret_key="admin",
|
||||
)
|
||||
|
||||
mock_s3.create_bucket.assert_called_once_with(Bucket="new-bucket")
|
||||
|
||||
def test_constructor_handles_bucket_creation_failure(self):
|
||||
"""Constructor logs warning but does not crash if bucket creation fails."""
|
||||
with patch.dict("sys.modules", {"boto3": MagicMock()}):
|
||||
import boto3 as mock_boto
|
||||
mock_s3 = MagicMock()
|
||||
mock_boto.client.return_value = mock_s3
|
||||
mock_s3.head_bucket.side_effect = Exception("Bucket not found")
|
||||
mock_s3.create_bucket.side_effect = Exception("Permission denied")
|
||||
|
||||
# Should not raise
|
||||
backend = S3StorageBackend(
|
||||
bucket="locked-bucket",
|
||||
endpoint_url="http://minio:9000",
|
||||
access_key="admin",
|
||||
secret_key="admin",
|
||||
)
|
||||
assert backend.bucket == "locked-bucket"
|
||||
|
||||
def test_constructor_passes_endpoint_and_credentials(self):
|
||||
"""Constructor passes endpoint_url and credentials to boto3.client."""
|
||||
with patch.dict("sys.modules", {"boto3": MagicMock()}):
|
||||
import boto3 as mock_boto
|
||||
mock_s3 = MagicMock()
|
||||
mock_boto.client.return_value = mock_s3
|
||||
|
||||
S3StorageBackend(
|
||||
bucket="test",
|
||||
endpoint_url="http://minio:9000",
|
||||
access_key="mykey",
|
||||
secret_key="mysecret",
|
||||
)
|
||||
|
||||
mock_boto.client.assert_called_with(
|
||||
"s3",
|
||||
endpoint_url="http://minio:9000",
|
||||
aws_access_key_id="mykey",
|
||||
aws_secret_access_key="mysecret",
|
||||
)
|
||||
|
||||
|
||||
# ---------- LocalStorageBackend ----------
|
||||
|
||||
class TestLocalStorageBackend:
|
||||
"""Basic sanity checks for the local filesystem backend."""
|
||||
|
||||
def test_write_and_read(self, tmp_path):
|
||||
"""Write and read round-trip produces identical content."""
|
||||
backend = LocalStorageBackend(base_dir=str(tmp_path))
|
||||
backend.write("test.pdf", b"hello world")
|
||||
|
||||
result = backend.read("test.pdf")
|
||||
assert result == b"hello world"
|
||||
|
||||
def test_read_missing_file_raises(self, tmp_path):
|
||||
"""Reading a non-existent file raises FileNotFoundError."""
|
||||
backend = LocalStorageBackend(base_dir=str(tmp_path))
|
||||
|
||||
with pytest.raises(FileNotFoundError):
|
||||
backend.read("nonexistent.pdf")
|
||||
|
||||
def test_exists_true_for_written_file(self, tmp_path):
|
||||
"""exists() returns True after writing a file."""
|
||||
backend = LocalStorageBackend(base_dir=str(tmp_path))
|
||||
backend.write("test.pdf", b"data")
|
||||
|
||||
assert backend.exists("test.pdf") is True
|
||||
|
||||
def test_exists_false_for_missing_file(self, tmp_path):
|
||||
"""exists() returns False for non-existent file."""
|
||||
backend = LocalStorageBackend(base_dir=str(tmp_path))
|
||||
|
||||
assert backend.exists("missing.pdf") is False
|
||||
|
||||
def test_exists_false_for_empty_file(self, tmp_path):
|
||||
"""exists() returns False for zero-length file."""
|
||||
backend = LocalStorageBackend(base_dir=str(tmp_path))
|
||||
backend.write("empty.pdf", b"")
|
||||
|
||||
assert backend.exists("empty.pdf") is False
|
||||
|
||||
def test_path_for_returns_full_path(self, tmp_path):
|
||||
"""path_for() returns the full filesystem path."""
|
||||
backend = LocalStorageBackend(base_dir=str(tmp_path))
|
||||
path = backend.path_for("test.pdf")
|
||||
|
||||
assert path == str(tmp_path / "test.pdf")
|
||||
|
||||
|
||||
# ---------- get_storage_backend() factory ----------
|
||||
|
||||
class TestGetStorageBackend:
|
||||
"""Tests for the storage backend factory function."""
|
||||
|
||||
@patch("SPARC.storage.config")
|
||||
def test_returns_local_backend_by_default(self, mock_config):
|
||||
"""Default config returns LocalStorageBackend."""
|
||||
mock_config.storage_backend = "local"
|
||||
|
||||
backend = get_storage_backend()
|
||||
|
||||
assert isinstance(backend, LocalStorageBackend)
|
||||
|
||||
@patch("SPARC.storage.config")
|
||||
def test_returns_s3_backend_when_configured(self, mock_config):
|
||||
"""Setting storage_backend=s3 returns S3StorageBackend."""
|
||||
mock_config.storage_backend = "s3"
|
||||
mock_config.s3_bucket = "test-bucket"
|
||||
mock_config.s3_endpoint_url = "http://minio:9000"
|
||||
mock_config.s3_access_key = "key"
|
||||
mock_config.s3_secret_key = "secret"
|
||||
|
||||
with patch.dict("sys.modules", {"boto3": MagicMock()}):
|
||||
backend = get_storage_backend()
|
||||
|
||||
assert isinstance(backend, S3StorageBackend)
|
||||
|
||||
@patch("SPARC.storage.config")
|
||||
def test_case_insensitive_backend_selection(self, mock_config):
|
||||
"""Backend selection is case-insensitive."""
|
||||
mock_config.storage_backend = "LOCAL"
|
||||
|
||||
backend = get_storage_backend()
|
||||
|
||||
assert isinstance(backend, LocalStorageBackend)
|
||||
@@ -0,0 +1,280 @@
|
||||
"""Tests for webhook notification system: retry logic and Slack/Discord payload format.
|
||||
|
||||
Covers issue #1657:
|
||||
- Retry logic with exponential backoff in _send_with_retry
|
||||
- Slack/Discord payload formatting in _build_payload
|
||||
- Generic HTTP POST payload formatting
|
||||
- notify() dispatching to multiple URLs
|
||||
- notify_job_completed() and notify_alert() convenience helpers
|
||||
"""
|
||||
|
||||
from datetime import datetime
|
||||
from unittest.mock import MagicMock, patch, call
|
||||
|
||||
import pytest
|
||||
import requests
|
||||
|
||||
from SPARC.webhooks import (
|
||||
MAX_RETRIES,
|
||||
_build_payload,
|
||||
_is_slack_url,
|
||||
_send_with_retry,
|
||||
notify,
|
||||
notify_alert,
|
||||
notify_job_completed,
|
||||
)
|
||||
|
||||
|
||||
class TestIsSlackUrl:
|
||||
"""Tests for Slack/Discord URL detection."""
|
||||
|
||||
def test_slack_webhook_url(self):
|
||||
assert _is_slack_url("https://hooks.slack.com/services/T00/B00/xxx") is True
|
||||
|
||||
def test_discord_webhook_url(self):
|
||||
assert _is_slack_url("https://discord.com/api/webhooks/123/abc") is True
|
||||
|
||||
def test_generic_url(self):
|
||||
assert _is_slack_url("https://example.com/webhook") is False
|
||||
|
||||
def test_empty_url(self):
|
||||
assert _is_slack_url("") is False
|
||||
|
||||
|
||||
class TestBuildPayload:
|
||||
"""Tests for payload construction."""
|
||||
|
||||
def test_generic_payload_structure(self):
|
||||
"""Generic payload includes event type, timestamp, and data."""
|
||||
payload = _build_payload("job_completed", {"job_id": "abc123"})
|
||||
|
||||
assert payload["event"] == "job_completed"
|
||||
assert payload["job_id"] == "abc123"
|
||||
assert "timestamp" in payload
|
||||
# Timestamp should be ISO format ending with Z
|
||||
assert payload["timestamp"].endswith("Z")
|
||||
|
||||
def test_slack_payload_wraps_in_text(self):
|
||||
"""Slack payload wraps content in a 'text' field."""
|
||||
payload = _build_payload("patent_alert", {"company_name": "NVIDIA"}, slack=True)
|
||||
|
||||
assert "text" in payload
|
||||
assert "patent_alert" in payload["text"]
|
||||
assert "NVIDIA" in payload["text"]
|
||||
# Slack payload should NOT have the event/timestamp at top level
|
||||
assert "event" not in payload
|
||||
assert "timestamp" not in payload
|
||||
|
||||
def test_generic_payload_does_not_have_text_field(self):
|
||||
"""Non-Slack payload does not wrap in text."""
|
||||
payload = _build_payload("job_completed", {"status": "done"})
|
||||
|
||||
assert "text" not in payload
|
||||
assert payload["status"] == "done"
|
||||
|
||||
def test_slack_payload_contains_bold_header(self):
|
||||
"""Slack payload starts with bold event header using Slack markdown."""
|
||||
payload = _build_payload("job_completed", {"count": 5}, slack=True)
|
||||
|
||||
assert payload["text"].startswith("*[SPARC] job_completed*")
|
||||
|
||||
def test_payload_merges_all_data_keys(self):
|
||||
"""All data keys are included in the generic payload."""
|
||||
data = {"key1": "val1", "key2": 42, "key3": True}
|
||||
payload = _build_payload("test_event", data)
|
||||
|
||||
assert payload["key1"] == "val1"
|
||||
assert payload["key2"] == 42
|
||||
assert payload["key3"] is True
|
||||
|
||||
|
||||
class TestSendWithRetry:
|
||||
"""Tests for retry logic in _send_with_retry."""
|
||||
|
||||
@patch("SPARC.webhooks.time.sleep")
|
||||
@patch("SPARC.webhooks.requests.post")
|
||||
def test_success_on_first_attempt(self, mock_post, mock_sleep):
|
||||
"""Successful delivery on first attempt, no retries."""
|
||||
mock_post.return_value = MagicMock(status_code=200)
|
||||
|
||||
result = _send_with_retry("https://example.com/hook", {"event": "test"})
|
||||
|
||||
assert result is True
|
||||
mock_post.assert_called_once()
|
||||
mock_sleep.assert_not_called()
|
||||
|
||||
@patch("SPARC.webhooks.time.sleep")
|
||||
@patch("SPARC.webhooks.requests.post")
|
||||
def test_success_on_second_attempt(self, mock_post, mock_sleep):
|
||||
"""Fails first, succeeds on retry."""
|
||||
mock_post.side_effect = [
|
||||
MagicMock(status_code=500),
|
||||
MagicMock(status_code=200),
|
||||
]
|
||||
|
||||
result = _send_with_retry("https://example.com/hook", {"event": "test"})
|
||||
|
||||
assert result is True
|
||||
assert mock_post.call_count == 2
|
||||
mock_sleep.assert_called_once()
|
||||
|
||||
@patch("SPARC.webhooks.time.sleep")
|
||||
@patch("SPARC.webhooks.requests.post")
|
||||
def test_all_retries_exhausted(self, mock_post, mock_sleep):
|
||||
"""Returns False after all retries fail."""
|
||||
mock_post.return_value = MagicMock(status_code=500)
|
||||
|
||||
result = _send_with_retry("https://example.com/hook", {"event": "test"})
|
||||
|
||||
assert result is False
|
||||
assert mock_post.call_count == MAX_RETRIES
|
||||
assert mock_sleep.call_count == MAX_RETRIES - 1
|
||||
|
||||
@patch("SPARC.webhooks.time.sleep")
|
||||
@patch("SPARC.webhooks.requests.post")
|
||||
def test_exponential_backoff_timing(self, mock_post, mock_sleep):
|
||||
"""Backoff wait times follow exponential pattern (2^attempt)."""
|
||||
mock_post.return_value = MagicMock(status_code=500)
|
||||
|
||||
_send_with_retry("https://example.com/hook", {"event": "test"})
|
||||
|
||||
# With BACKOFF_BASE=2: attempt 1 -> sleep(2), attempt 2 -> sleep(4)
|
||||
expected_waits = [call(2 ** i) for i in range(1, MAX_RETRIES)]
|
||||
assert mock_sleep.call_args_list == expected_waits
|
||||
|
||||
@patch("SPARC.webhooks.time.sleep")
|
||||
@patch("SPARC.webhooks.requests.post")
|
||||
def test_network_error_triggers_retry(self, mock_post, mock_sleep):
|
||||
"""Network exceptions trigger retry, not immediate failure."""
|
||||
mock_post.side_effect = [
|
||||
requests.ConnectionError("Connection refused"),
|
||||
MagicMock(status_code=200),
|
||||
]
|
||||
|
||||
result = _send_with_retry("https://example.com/hook", {"event": "test"})
|
||||
|
||||
assert result is True
|
||||
assert mock_post.call_count == 2
|
||||
|
||||
@patch("SPARC.webhooks.time.sleep")
|
||||
@patch("SPARC.webhooks.requests.post")
|
||||
def test_timeout_error_triggers_retry(self, mock_post, mock_sleep):
|
||||
"""Timeout exceptions trigger retry."""
|
||||
mock_post.side_effect = [
|
||||
requests.Timeout("Request timed out"),
|
||||
MagicMock(status_code=200),
|
||||
]
|
||||
|
||||
result = _send_with_retry("https://example.com/hook", {"event": "test"})
|
||||
|
||||
assert result is True
|
||||
assert mock_post.call_count == 2
|
||||
|
||||
@patch("SPARC.webhooks.time.sleep")
|
||||
@patch("SPARC.webhooks.requests.post")
|
||||
def test_2xx_status_codes_accepted(self, mock_post, mock_sleep):
|
||||
"""Any 2xx status code is treated as success."""
|
||||
mock_post.return_value = MagicMock(status_code=204)
|
||||
|
||||
result = _send_with_retry("https://example.com/hook", {"event": "test"})
|
||||
|
||||
assert result is True
|
||||
mock_post.assert_called_once()
|
||||
|
||||
@patch("SPARC.webhooks.time.sleep")
|
||||
@patch("SPARC.webhooks.requests.post")
|
||||
def test_posts_json_payload(self, mock_post, mock_sleep):
|
||||
"""Payload is sent as JSON with correct timeout."""
|
||||
mock_post.return_value = MagicMock(status_code=200)
|
||||
payload = {"event": "test", "data": "value"}
|
||||
|
||||
_send_with_retry("https://example.com/hook", payload)
|
||||
|
||||
mock_post.assert_called_once_with(
|
||||
"https://example.com/hook", json=payload, timeout=10
|
||||
)
|
||||
|
||||
|
||||
class TestNotify:
|
||||
"""Tests for the notify() dispatcher."""
|
||||
|
||||
@patch("SPARC.webhooks._send_with_retry")
|
||||
@patch("SPARC.webhooks.WEBHOOK_URLS", ["https://example.com/hook1", "https://example.com/hook2"])
|
||||
def test_dispatches_to_all_urls(self, mock_send):
|
||||
"""notify() sends to every configured webhook URL."""
|
||||
mock_send.return_value = True
|
||||
|
||||
notify("job_completed", {"job_id": "test123"})
|
||||
|
||||
assert mock_send.call_count == 2
|
||||
|
||||
@patch("SPARC.webhooks._send_with_retry")
|
||||
@patch("SPARC.webhooks.WEBHOOK_URLS", [])
|
||||
def test_no_urls_configured_returns_immediately(self, mock_send):
|
||||
"""No-op when no webhook URLs are configured."""
|
||||
notify("job_completed", {"job_id": "test123"})
|
||||
|
||||
mock_send.assert_not_called()
|
||||
|
||||
@patch("SPARC.webhooks._send_with_retry")
|
||||
@patch("SPARC.webhooks.WEBHOOK_URLS", [
|
||||
"https://hooks.slack.com/services/T00/B00/xxx",
|
||||
"https://example.com/generic",
|
||||
])
|
||||
def test_slack_url_gets_slack_payload(self, mock_send):
|
||||
"""Slack URLs receive Slack-formatted payloads, others get generic."""
|
||||
mock_send.return_value = True
|
||||
|
||||
notify("test_event", {"key": "val"})
|
||||
|
||||
# First call (Slack URL) should have "text" key
|
||||
slack_payload = mock_send.call_args_list[0][0][1]
|
||||
assert "text" in slack_payload
|
||||
|
||||
# Second call (generic URL) should have "event" key
|
||||
generic_payload = mock_send.call_args_list[1][0][1]
|
||||
assert "event" in generic_payload
|
||||
assert generic_payload["event"] == "test_event"
|
||||
|
||||
|
||||
class TestNotifyJobCompleted:
|
||||
"""Tests for notify_job_completed() convenience function."""
|
||||
|
||||
@patch("SPARC.webhooks.notify")
|
||||
def test_sends_correct_event_and_data(self, mock_notify):
|
||||
"""Job completion sends proper event type and summary."""
|
||||
notify_job_completed(
|
||||
job_id="batch-001",
|
||||
status="completed",
|
||||
total_companies=10,
|
||||
successful=8,
|
||||
failed=2,
|
||||
)
|
||||
|
||||
mock_notify.assert_called_once()
|
||||
event, data = mock_notify.call_args[0]
|
||||
assert event == "job_completed"
|
||||
assert data["job_id"] == "batch-001"
|
||||
assert data["successful"] == 8
|
||||
assert data["failed"] == 2
|
||||
assert "8/10" in data["summary"]
|
||||
|
||||
|
||||
class TestNotifyAlert:
|
||||
"""Tests for notify_alert() convenience function."""
|
||||
|
||||
@patch("SPARC.webhooks.notify")
|
||||
def test_sends_correct_event_and_data(self, mock_notify):
|
||||
"""Alert notification sends patent_alert event type."""
|
||||
notify_alert(
|
||||
company_name="NVIDIA",
|
||||
alert_type="patent_count_change",
|
||||
message="Patent count increased by 30%",
|
||||
)
|
||||
|
||||
mock_notify.assert_called_once()
|
||||
event, data = mock_notify.call_args[0]
|
||||
assert event == "patent_alert"
|
||||
assert data["company_name"] == "NVIDIA"
|
||||
assert data["alert_type"] == "patent_count_change"
|
||||
assert "30%" in data["message"]
|
||||
Reference in New Issue
Block a user