mirror of
https://github.com/element-hq/ess-helm.git
synced 2026-11-20 09:01:32 -08:00
278 lines
9.9 KiB
Python
278 lines
9.9 KiB
Python
# Copyright 2026 Element Creations Ltd
|
|
#
|
|
# SPDX-License-Identifier: AGPL-3.0-only
|
|
|
|
import asyncio
|
|
import json
|
|
import time
|
|
from urllib.parse import urlparse
|
|
|
|
import pytest
|
|
from lightkube import AsyncClient
|
|
|
|
from .fixtures import ESSData, User
|
|
from .lib.utils import aiohttp_client, aiohttp_get_json, aiohttp_post_json, aiohttp_put_json, value_file_has
|
|
|
|
|
|
# This creates an unencrypted room, invites hookshot, creates a webhook,
|
|
# and verifies that hookshot posts webhook payloads to the room
|
|
@pytest.mark.skipif(not value_file_has("hookshot.enabled", True), reason="Hookshot not enabled")
|
|
@pytest.mark.parametrize("users", [(User(name="hookshot-user"),)], indirect=True)
|
|
@pytest.mark.asyncio_cooperative
|
|
async def test_hookshot_webhook(
|
|
kube_client: AsyncClient,
|
|
ingress_ready,
|
|
generated_data: ESSData,
|
|
users,
|
|
ssl_context,
|
|
):
|
|
await ingress_ready("synapse")
|
|
user_access_token = users[0].access_token
|
|
hookshot_mxid = f"@hookshot:{generated_data.server_name}"
|
|
# Create an unencrypted room
|
|
create_room_request = {
|
|
"name": "Hookshot webhook test",
|
|
"preset": "private_chat",
|
|
"visibility": "private",
|
|
}
|
|
|
|
create_room = await aiohttp_post_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/createRoom",
|
|
create_room_request,
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
|
|
room_id = create_room["room_id"]
|
|
|
|
# Invite hookshot to the room
|
|
invite_request = {
|
|
"user_id": hookshot_mxid,
|
|
}
|
|
|
|
await aiohttp_post_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/rooms/{room_id}/invite",
|
|
invite_request,
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
|
|
# Wait for hookshot to join
|
|
count = 0
|
|
while count < 10:
|
|
members_response = await aiohttp_get_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/rooms/{room_id}/members",
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
# Extract joined members from the membership events
|
|
joined_members = [
|
|
event["state_key"]
|
|
for event in members_response.get("chunk", [])
|
|
if event.get("content", {}).get("membership") == "join"
|
|
]
|
|
if hookshot_mxid in joined_members:
|
|
break
|
|
else:
|
|
await asyncio.sleep(3)
|
|
count = count + 1
|
|
|
|
assert hookshot_mxid in joined_members, f"Hookshot did not join the room : {json.dumps(members_response)}"
|
|
|
|
# Get current power levels
|
|
power_levels = await aiohttp_get_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/rooms/{room_id}/state/m.room.power_levels",
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
|
|
# Promote hookshot to moderator (power level 50)
|
|
if "users" not in power_levels:
|
|
power_levels["users"] = {}
|
|
|
|
power_levels["users"][hookshot_mxid] = 50
|
|
|
|
await aiohttp_put_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/rooms/{room_id}/state/m.room.power_levels",
|
|
power_levels,
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
|
|
# Generate a random webhook id
|
|
webhook_id = f"{generated_data.server_name}-{create_room['room_id']}"[:64]
|
|
webhook_command = {
|
|
"msgtype": "m.text",
|
|
"body": f"!hookshot webhook {webhook_id}",
|
|
}
|
|
webhook_create_ts = int(time.time() * 1000)
|
|
|
|
await aiohttp_post_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/rooms/{room_id}/send/m.room.message",
|
|
webhook_command,
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
|
|
# Wait for hookshot to send an invite to the admin room
|
|
admin_room_id = None
|
|
count = 0
|
|
next_batch = None
|
|
|
|
# This finds the admin room either from the joined state or from the invite state
|
|
def _find_admin_room_in_room_data(rooms: dict):
|
|
admin_room_id = None
|
|
for room, room_data in rooms.items():
|
|
join_state = room_data.get("timeline", {}).get("events", []) + room_data.get("state", {}).get("events", [])
|
|
invite_state = room_data.get("invite_state", {}).get("events", [])
|
|
# Check if one of the room is created by hookshot
|
|
for state_events in join_state:
|
|
# This assumes that the admin room is the only room created by hookshot in our test suite
|
|
if state_events.get("sender") == hookshot_mxid and state_events.get("type") == "m.room.create":
|
|
admin_room_id = room
|
|
break
|
|
else:
|
|
# Check if the invite is from hookshot
|
|
for event in invite_state:
|
|
# This assumes that the admin room is the only room created by hookshot in our test suite
|
|
if event.get("sender") == hookshot_mxid and event.get("type") == "m.room.member":
|
|
admin_room_id = room
|
|
break
|
|
return admin_room_id
|
|
|
|
while count < 10:
|
|
# Sync to get invited rooms
|
|
sync_args = f"since={next_batch}" if next_batch else "full_state=true"
|
|
sync_response = await aiohttp_get_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/sync?{sync_args}&timeout=1000",
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
|
|
if sync_response.get("next_batch"):
|
|
next_batch = sync_response.get("next_batch")
|
|
|
|
# Check for joined rooms, if hookshot already invited the user to the admin room
|
|
joined_rooms: dict = sync_response.get("rooms", {}).get("join", {})
|
|
invited_rooms: dict = sync_response.get("rooms", {}).get("invite", {})
|
|
admin_room_id = _find_admin_room_in_room_data(joined_rooms | invited_rooms)
|
|
|
|
if admin_room_id:
|
|
break
|
|
else:
|
|
await asyncio.sleep(3)
|
|
count = count + 1
|
|
|
|
assert admin_room_id is not None, f"Hookshot did not send admin room invite : {json.dumps(sync_response)}"
|
|
|
|
# Accept the invite to the admin room
|
|
await aiohttp_post_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/rooms/{admin_room_id}/join",
|
|
{},
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
|
|
# Wait for and extract webhook URL from hookshot's response in the admin room
|
|
webhook_url = None
|
|
count = 0
|
|
while count < 10:
|
|
messages = await aiohttp_get_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/rooms/{admin_room_id}/messages?dir=b&limit=10",
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
|
|
# Look for hookshot's response containing the webhook URL
|
|
for event in messages.get("chunk", []):
|
|
if (
|
|
event.get("sender") == hookshot_mxid
|
|
and "body" in event.get("content", {})
|
|
and event["origin_server_ts"] > webhook_create_ts
|
|
):
|
|
body = event["content"]["body"]
|
|
if "http" in body:
|
|
# The webhook URL is the last line of the message
|
|
webhook_url = body.split("\n")[-1].strip()
|
|
assert urlparse(webhook_url).hostname == f"synapse.{generated_data.server_name}", (
|
|
f"Unexpected webhook URL found in admin room : {body}"
|
|
)
|
|
assert urlparse(webhook_url).scheme == "https", (
|
|
f"Unexpected webhook scheme found in admin room : {body}"
|
|
)
|
|
break
|
|
|
|
if webhook_url:
|
|
break
|
|
else:
|
|
await asyncio.sleep(3)
|
|
count = count + 1
|
|
|
|
assert webhook_url is not None, f"Failed to create webhook : {json.dumps(messages)}"
|
|
|
|
# Send a test payload to the webhook
|
|
test_payload = {
|
|
"text": "Test webhook payload",
|
|
}
|
|
|
|
answer = await aiohttp_post_json(
|
|
webhook_url,
|
|
test_payload,
|
|
{},
|
|
ssl_context,
|
|
)
|
|
assert answer["ok"]
|
|
|
|
# Wait for hookshot to post the payload to the room
|
|
payload_found = False
|
|
count = 0
|
|
while count < 10:
|
|
messages = await aiohttp_get_json(
|
|
f"https://synapse.{generated_data.server_name}/_matrix/client/v3/rooms/{room_id}/messages?dir=b&limit=20",
|
|
{"Authorization": f"Bearer {user_access_token}"},
|
|
ssl_context,
|
|
)
|
|
|
|
# Look for message from hookshot containing our payload
|
|
for event in messages.get("chunk", []):
|
|
if event.get("sender") == hookshot_mxid and "body" in event.get("content", {}):
|
|
body = event["content"]["body"]
|
|
if "Test webhook payload" in body:
|
|
payload_found = True
|
|
break
|
|
|
|
if payload_found:
|
|
break
|
|
else:
|
|
await asyncio.sleep(3)
|
|
count = count + 1
|
|
|
|
assert payload_found, (
|
|
f"Hookshot answered {answer} but did not post webhook {webhook_id} payload to room : {json.dumps(messages)}"
|
|
)
|
|
|
|
return room_id
|
|
|
|
|
|
# This creates an unencrypted room, invites hookshot, creates a webhook,
|
|
# and verifies that hookshot posts webhook payloads to the room
|
|
@pytest.mark.skipif(not value_file_has("hookshot.enabled", True), reason="Hookshot not enabled")
|
|
@pytest.mark.asyncio_cooperative
|
|
async def test_hookshot_widget(
|
|
kube_client: AsyncClient,
|
|
ingress_ready,
|
|
generated_data: ESSData,
|
|
ssl_context,
|
|
):
|
|
await ingress_ready("synapse")
|
|
|
|
async with (
|
|
aiohttp_client(ssl_context) as client,
|
|
client.get(
|
|
"https://127.0.0.1/_matrix/hookshot/widgetapi/v1/static",
|
|
headers={"Host": f"synapse.{generated_data.server_name}"},
|
|
server_hostname=f"synapse.{generated_data.server_name}",
|
|
) as response,
|
|
):
|
|
assert response.status != 404
|