mirror of
https://github.com/dograh-hq/dograh.git
synced 2026-06-07 07:55:16 +02:00
420 lines
17 KiB
Python
420 lines
17 KiB
Python
"""
|
|
Tests for get_backend_endpoints function in api/utils/common.py
|
|
|
|
Expected behavior:
|
|
- Output URLs must always have a scheme (http:// or https://, ws:// or wss://)
|
|
- Output URLs must NOT have trailing slashes
|
|
"""
|
|
|
|
from unittest.mock import AsyncMock, patch
|
|
|
|
import pytest
|
|
|
|
from api.utils.common import get_backend_endpoints, get_scheme
|
|
|
|
# Valid test URLs covering various formats
|
|
possible_env_paths = [
|
|
"http://localhost",
|
|
"http://localhost/",
|
|
"http://localhost:8000",
|
|
"http://localhost:8000/",
|
|
"http://127.0.0.1",
|
|
"http://127.0.0.1/",
|
|
"http://127.0.0.1:8000",
|
|
"http://127.0.0.1:8000/",
|
|
"http://xyz.com",
|
|
"http://xyz.com/",
|
|
"https://xyz.com",
|
|
"https://xyz.com/",
|
|
"localhost",
|
|
"localhost:8000",
|
|
"localhost/",
|
|
"localhost:8000/",
|
|
"xyz.com",
|
|
"xyz.com/",
|
|
"127.0.0.1",
|
|
"127.0.0.1/",
|
|
"127.0.0.1:8000",
|
|
"127.0.0.1:8000/",
|
|
]
|
|
|
|
# Invalid URLs that should raise ValueError
|
|
invalid_env_paths = [
|
|
"http:/localhost", # Typo: single slash in scheme
|
|
"http:/xyz.com", # Typo: single slash in scheme
|
|
"https:/xyz.com", # Typo: single slash in scheme
|
|
"htp://xyz.com", # Typo: missing 't' in http
|
|
"htps://xyz.com", # Typo: missing 't' in https
|
|
"http//xyz.com", # Missing colon
|
|
"http:xyz.com", # Missing slashes
|
|
"http://xyz.com:abc", # Invalid port (non-numeric)
|
|
"http://xyz.com:-1", # Invalid port (negative)
|
|
"http://xyz.com:99999", # Invalid port (out of range)
|
|
"http://", # Missing host
|
|
"https://", # Missing host
|
|
"http:// ", # Whitespace host
|
|
"http://xyz .com", # Space in hostname
|
|
"http://xyz\t.com", # Tab in hostname
|
|
"http://xyz\n.com", # Newline in hostname
|
|
"", # Empty string
|
|
" ", # Only whitespace
|
|
]
|
|
|
|
|
|
class TestGetScheme:
|
|
"""Tests for the get_scheme helper function."""
|
|
|
|
def test_http_scheme(self):
|
|
assert get_scheme("http://example.com") == "http"
|
|
|
|
def test_https_scheme(self):
|
|
assert get_scheme("https://example.com") == "https"
|
|
|
|
def test_no_scheme(self):
|
|
assert get_scheme("example.com") is None
|
|
assert get_scheme("localhost:8000") is None
|
|
|
|
def test_malformed_url_single_slash(self):
|
|
# 'http:/localhost' doesn't have '://' so returns None
|
|
assert get_scheme("http:/localhost") is None
|
|
|
|
def test_ws_scheme(self):
|
|
assert get_scheme("ws://example.com") == "ws"
|
|
assert get_scheme("wss://example.com") == "wss"
|
|
|
|
|
|
class TestGetBackendEndpointsWithEnvVar:
|
|
"""Tests for get_backend_endpoints when BACKEND_API_ENDPOINT is set."""
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"env_url,expected_http,expected_ws",
|
|
[
|
|
# URLs with http:// scheme (with and without trailing slash -> no trailing slash)
|
|
("http://xyz.com", "http://xyz.com", "ws://xyz.com"),
|
|
("http://xyz.com/", "http://xyz.com", "ws://xyz.com"),
|
|
# URLs with https:// scheme (with and without trailing slash -> no trailing slash)
|
|
("https://xyz.com", "https://xyz.com", "wss://xyz.com"),
|
|
("https://xyz.com/", "https://xyz.com", "wss://xyz.com"),
|
|
# URLs without scheme (should add http/ws, no trailing slash)
|
|
("xyz.com", "http://xyz.com", "ws://xyz.com"),
|
|
("xyz.com/", "http://xyz.com", "ws://xyz.com"),
|
|
],
|
|
)
|
|
async def test_non_localhost_urls(self, env_url, expected_http, expected_ws):
|
|
"""Test non-localhost URLs return correct http and ws endpoints."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", env_url):
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == expected_http
|
|
assert ws_url == expected_ws
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"env_url,expected_http,expected_ws",
|
|
[
|
|
# localhost URLs with http:// scheme
|
|
("http://localhost", "http://localhost", "ws://localhost"),
|
|
("http://localhost/", "http://localhost", "ws://localhost"),
|
|
("http://localhost:8000", "http://localhost:8000", "ws://localhost:8000"),
|
|
("http://localhost:8000/", "http://localhost:8000", "ws://localhost:8000"),
|
|
# localhost URLs without scheme (should add http/ws)
|
|
("localhost", "http://localhost", "ws://localhost"),
|
|
("localhost/", "http://localhost", "ws://localhost"),
|
|
("localhost:8000", "http://localhost:8000", "ws://localhost:8000"),
|
|
("localhost:8000/", "http://localhost:8000", "ws://localhost:8000"),
|
|
# 127.0.0.1 URLs with http:// scheme
|
|
("http://127.0.0.1", "http://127.0.0.1", "ws://127.0.0.1"),
|
|
("http://127.0.0.1/", "http://127.0.0.1", "ws://127.0.0.1"),
|
|
("http://127.0.0.1:8000", "http://127.0.0.1:8000", "ws://127.0.0.1:8000"),
|
|
("http://127.0.0.1:8000/", "http://127.0.0.1:8000", "ws://127.0.0.1:8000"),
|
|
# 127.0.0.1 URLs without scheme (should add http/ws)
|
|
("127.0.0.1", "http://127.0.0.1", "ws://127.0.0.1"),
|
|
("127.0.0.1/", "http://127.0.0.1", "ws://127.0.0.1"),
|
|
("127.0.0.1:8000", "http://127.0.0.1:8000", "ws://127.0.0.1:8000"),
|
|
("127.0.0.1:8000/", "http://127.0.0.1:8000", "ws://127.0.0.1:8000"),
|
|
],
|
|
)
|
|
async def test_localhost_urls_no_tunnel(self, env_url, expected_http, expected_ws):
|
|
"""Test localhost/127.0.0.1 URLs when tunnel is not available."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", env_url):
|
|
with patch(
|
|
"api.utils.common.TunnelURLProvider.get_tunnel_urls",
|
|
new_callable=AsyncMock,
|
|
) as mock_tunnel:
|
|
mock_tunnel.return_value = None
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == expected_http
|
|
assert ws_url == expected_ws
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"env_url",
|
|
[
|
|
"http://localhost",
|
|
"http://localhost/",
|
|
"http://localhost:8000",
|
|
"http://localhost:8000/",
|
|
"localhost",
|
|
"localhost/",
|
|
"localhost:8000",
|
|
"localhost:8000/",
|
|
"http://127.0.0.1",
|
|
"http://127.0.0.1/",
|
|
"http://127.0.0.1:8000",
|
|
"http://127.0.0.1:8000/",
|
|
"127.0.0.1",
|
|
"127.0.0.1/",
|
|
"127.0.0.1:8000",
|
|
"127.0.0.1:8000/",
|
|
],
|
|
)
|
|
async def test_localhost_urls_with_tunnel_available(self, env_url):
|
|
"""Test localhost/127.0.0.1 URLs prefer tunnel when available."""
|
|
tunnel_http = "https://abc123.trycloudflare.com"
|
|
tunnel_ws = "wss://abc123.trycloudflare.com"
|
|
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", env_url):
|
|
with patch(
|
|
"api.utils.common.TunnelURLProvider.get_tunnel_urls",
|
|
new_callable=AsyncMock,
|
|
) as mock_tunnel:
|
|
mock_tunnel.return_value = (tunnel_http, tunnel_ws)
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == tunnel_http
|
|
assert ws_url == tunnel_ws
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_localhost_tunnel_exception_falls_back(self):
|
|
"""Test that tunnel exceptions fall back to localhost endpoint."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", "http://localhost:8000"):
|
|
with patch(
|
|
"api.utils.common.TunnelURLProvider.get_tunnel_urls",
|
|
new_callable=AsyncMock,
|
|
) as mock_tunnel:
|
|
mock_tunnel.side_effect = Exception("Tunnel not available")
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == "http://localhost:8000"
|
|
assert ws_url == "ws://localhost:8000"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_localhost_with_trailing_slash_tunnel_exception_falls_back(self):
|
|
"""Test that tunnel exceptions fall back to localhost endpoint, trailing slash stripped."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", "http://localhost:8000/"):
|
|
with patch(
|
|
"api.utils.common.TunnelURLProvider.get_tunnel_urls",
|
|
new_callable=AsyncMock,
|
|
) as mock_tunnel:
|
|
mock_tunnel.side_effect = Exception("Tunnel not available")
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == "http://localhost:8000"
|
|
assert ws_url == "ws://localhost:8000"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_127_tunnel_exception_falls_back(self):
|
|
"""Test that tunnel exceptions fall back to 127.0.0.1 endpoint."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", "http://127.0.0.1:8000"):
|
|
with patch(
|
|
"api.utils.common.TunnelURLProvider.get_tunnel_urls",
|
|
new_callable=AsyncMock,
|
|
) as mock_tunnel:
|
|
mock_tunnel.side_effect = Exception("Tunnel not available")
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == "http://127.0.0.1:8000"
|
|
assert ws_url == "ws://127.0.0.1:8000"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_127_with_trailing_slash_tunnel_exception_falls_back(self):
|
|
"""Test that tunnel exceptions fall back to 127.0.0.1 endpoint, trailing slash stripped."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", "http://127.0.0.1:8000/"):
|
|
with patch(
|
|
"api.utils.common.TunnelURLProvider.get_tunnel_urls",
|
|
new_callable=AsyncMock,
|
|
) as mock_tunnel:
|
|
mock_tunnel.side_effect = Exception("Tunnel not available")
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == "http://127.0.0.1:8000"
|
|
assert ws_url == "ws://127.0.0.1:8000"
|
|
|
|
|
|
class TestGetBackendEndpointsNoEnvVar:
|
|
"""Tests for get_backend_endpoints when BACKEND_API_ENDPOINT is not set."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_uses_tunnel_when_no_env_var(self):
|
|
"""Test that tunnel URLs are used when env var is not set."""
|
|
tunnel_http = "https://abc123.trycloudflare.com"
|
|
tunnel_ws = "wss://abc123.trycloudflare.com"
|
|
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", None):
|
|
with patch(
|
|
"api.utils.common.TunnelURLProvider.get_tunnel_urls",
|
|
new_callable=AsyncMock,
|
|
) as mock_tunnel:
|
|
mock_tunnel.return_value = (tunnel_http, tunnel_ws)
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == tunnel_http
|
|
assert ws_url == tunnel_ws
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_raises_when_no_env_var_and_no_tunnel(self):
|
|
"""Test that ValueError is raised when no env var and no tunnel."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", None):
|
|
with patch(
|
|
"api.utils.common.TunnelURLProvider.get_tunnel_urls",
|
|
new_callable=AsyncMock,
|
|
) as mock_tunnel:
|
|
mock_tunnel.return_value = None
|
|
with pytest.raises(ValueError, match="No tunnel URL available"):
|
|
await get_backend_endpoints()
|
|
|
|
|
|
class TestSchemeMapping:
|
|
"""Tests to verify correct scheme mapping (http->ws, https->wss)."""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_http_maps_to_ws(self):
|
|
"""Test http:// maps to ws://"""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", "http://example.com"):
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == "http://example.com"
|
|
assert ws_url == "ws://example.com"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_https_maps_to_wss(self):
|
|
"""Test https:// maps to wss://"""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", "https://example.com"):
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == "https://example.com"
|
|
assert ws_url == "wss://example.com"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_no_scheme_defaults_to_http_ws(self):
|
|
"""Test URLs without scheme default to http:// and ws://"""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", "example.com"):
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == "http://example.com"
|
|
assert ws_url == "ws://example.com"
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_trailing_slash_stripped(self):
|
|
"""Test trailing slashes are stripped from output."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", "http://example.com/"):
|
|
http_url, ws_url = await get_backend_endpoints()
|
|
assert http_url == "http://example.com"
|
|
assert ws_url == "ws://example.com"
|
|
assert not http_url.endswith("/")
|
|
assert not ws_url.endswith("/")
|
|
|
|
|
|
class TestInvalidUrls:
|
|
"""Tests for invalid URLs that should raise ValueError."""
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"invalid_url",
|
|
[
|
|
"http:/localhost", # Typo: single slash in scheme
|
|
"http:/xyz.com", # Typo: single slash in scheme
|
|
"https:/xyz.com", # Typo: single slash in scheme
|
|
],
|
|
)
|
|
async def test_malformed_scheme_single_slash(self, invalid_url):
|
|
"""Test URLs with single slash in scheme raise ValueError."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", invalid_url):
|
|
with patch(
|
|
"api.utils.common.TunnelURLProvider.get_tunnel_urls",
|
|
new_callable=AsyncMock,
|
|
) as mock_tunnel:
|
|
mock_tunnel.return_value = None
|
|
with pytest.raises(ValueError, match="Invalid BACKEND_API_ENDPOINT"):
|
|
await get_backend_endpoints()
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"invalid_url",
|
|
[
|
|
"htp://xyz.com", # Typo: missing 't' in http
|
|
"htps://xyz.com", # Typo: missing 't' in https
|
|
"ftp://xyz.com", # Unsupported scheme
|
|
"file://xyz.com", # Unsupported scheme
|
|
],
|
|
)
|
|
async def test_invalid_or_unsupported_scheme(self, invalid_url):
|
|
"""Test URLs with invalid or unsupported schemes raise ValueError."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", invalid_url):
|
|
with pytest.raises(ValueError, match="Invalid BACKEND_API_ENDPOINT"):
|
|
await get_backend_endpoints()
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"invalid_url",
|
|
[
|
|
"http//xyz.com", # Missing colon
|
|
"http:xyz.com", # Missing slashes
|
|
],
|
|
)
|
|
async def test_malformed_scheme_separator(self, invalid_url):
|
|
"""Test URLs with malformed scheme separators raise ValueError."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", invalid_url):
|
|
with pytest.raises(ValueError, match="Invalid BACKEND_API_ENDPOINT"):
|
|
await get_backend_endpoints()
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"invalid_url",
|
|
[
|
|
"http://xyz.com:abc", # Invalid port (non-numeric)
|
|
"http://xyz.com:-1", # Invalid port (negative)
|
|
"http://xyz.com:99999", # Invalid port (out of range)
|
|
"http://xyz.com:", # Empty port
|
|
],
|
|
)
|
|
async def test_invalid_port(self, invalid_url):
|
|
"""Test URLs with invalid ports raise ValueError."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", invalid_url):
|
|
with pytest.raises(ValueError, match="Invalid BACKEND_API_ENDPOINT"):
|
|
await get_backend_endpoints()
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"invalid_url",
|
|
[
|
|
"http://", # Missing host
|
|
"https://", # Missing host
|
|
],
|
|
)
|
|
async def test_missing_host(self, invalid_url):
|
|
"""Test URLs with missing host raise ValueError."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", invalid_url):
|
|
with pytest.raises(ValueError, match="Invalid BACKEND_API_ENDPOINT"):
|
|
await get_backend_endpoints()
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"invalid_url",
|
|
[
|
|
"http:// ", # Whitespace host
|
|
"http://xyz .com", # Space in hostname
|
|
"http://xyz\t.com", # Tab in hostname
|
|
"http://xyz\n.com", # Newline in hostname
|
|
],
|
|
)
|
|
async def test_invalid_characters_in_host(self, invalid_url):
|
|
"""Test URLs with invalid characters in hostname raise ValueError."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", invalid_url):
|
|
with pytest.raises(ValueError, match="Invalid BACKEND_API_ENDPOINT"):
|
|
await get_backend_endpoints()
|
|
|
|
@pytest.mark.asyncio
|
|
@pytest.mark.parametrize(
|
|
"invalid_url",
|
|
[
|
|
"", # Empty string
|
|
" ", # Only whitespace
|
|
],
|
|
)
|
|
async def test_empty_or_whitespace_url(self, invalid_url):
|
|
"""Test empty or whitespace-only URLs raise ValueError."""
|
|
with patch("api.utils.common.BACKEND_API_ENDPOINT", invalid_url):
|
|
with pytest.raises(ValueError, match="Invalid BACKEND_API_ENDPOINT"):
|
|
await get_backend_endpoints()
|