152 lines
5.0 KiB
Python
152 lines
5.0 KiB
Python
import json
|
|
import tempfile
|
|
import time
|
|
import unittest
|
|
from pathlib import Path, PurePosixPath
|
|
|
|
from archive_clients.config import ServiceConfig
|
|
from archive_clients.syncthing import (
|
|
RoutePathConflict,
|
|
RouteSetupTimeout,
|
|
SyncthingRouteManager,
|
|
)
|
|
from archive_control.v1 import route_pb2
|
|
|
|
|
|
class FakeTransport:
|
|
def __init__(self):
|
|
self.status = {"myID": "LOCAL"}
|
|
self.config = {"devices": [], "folders": []}
|
|
self.puts = []
|
|
self.posts = []
|
|
|
|
def get_json(self, path):
|
|
if path == "/rest/system/status":
|
|
return self.status
|
|
if path == "/rest/config":
|
|
return self.config
|
|
raise AssertionError(path)
|
|
|
|
def put_json(self, path, payload):
|
|
self.puts.append((path, payload))
|
|
if path.startswith("/rest/config/devices/"):
|
|
self.config["devices"].append(payload)
|
|
elif path.startswith("/rest/config/folders/"):
|
|
self.config["folders"].append(payload)
|
|
else:
|
|
raise AssertionError(path)
|
|
|
|
def post(self, path):
|
|
self.posts.append(path)
|
|
|
|
|
|
class SyncthingRouteManagerTests(unittest.TestCase):
|
|
def setUp(self):
|
|
self.temp_dir = tempfile.TemporaryDirectory()
|
|
self.root = Path(self.temp_dir.name) / "sync"
|
|
self.root.mkdir()
|
|
self.transport = FakeTransport()
|
|
self.manager = SyncthingRouteManager(
|
|
ServiceConfig(
|
|
"http://syncthing",
|
|
PurePosixPath("/sync"),
|
|
self.root,
|
|
),
|
|
sparse_supported=True,
|
|
transport=self.transport,
|
|
poll_interval=0,
|
|
)
|
|
self.spec = route_pb2.EnsureRouteSpec(
|
|
route_id="route-1",
|
|
peer_client_id="archive-1",
|
|
peer_syncthing_device_id="PEER",
|
|
peer_addresses=["tcp://archive:22000"],
|
|
local_relative_path="routes/route-1",
|
|
setup_timeout_seconds=1800,
|
|
)
|
|
|
|
def tearDown(self):
|
|
self.temp_dir.cleanup()
|
|
|
|
def test_configure_adds_only_peer_and_pairwise_folder(self):
|
|
configured = self.manager.configure(
|
|
self.spec, time.monotonic() + 1
|
|
)
|
|
self.assertEqual(configured.local_device_id, "LOCAL")
|
|
self.assertTrue(configured.local_path.is_dir())
|
|
self.assertEqual(len(self.transport.puts), 2)
|
|
folder = self.transport.config["folders"][0]
|
|
self.assertEqual(folder["path"], "/sync/routes/route-1")
|
|
self.assertEqual(folder["type"], "sendreceive")
|
|
self.assertEqual(
|
|
{item["deviceID"] for item in folder["devices"]},
|
|
{"LOCAL", "PEER"},
|
|
)
|
|
self.assertTrue(configured.local_route.archive_control_created)
|
|
|
|
repeated = self.manager.configure(self.spec, time.monotonic() + 1)
|
|
self.assertEqual(len(self.transport.puts), 2)
|
|
self.assertFalse(repeated.local_route.archive_control_created)
|
|
|
|
def test_existing_folder_conflicts_are_never_overwritten(self):
|
|
self.transport.config["folders"].append(
|
|
{
|
|
"id": "route-1",
|
|
"path": "/somewhere-else",
|
|
"type": "sendreceive",
|
|
"devices": [{"deviceID": "LOCAL"}, {"deviceID": "PEER"}],
|
|
}
|
|
)
|
|
with self.assertRaisesRegex(RoutePathConflict, "different path"):
|
|
self.manager.configure(self.spec, time.monotonic() + 1)
|
|
self.assertEqual(self.transport.puts, [])
|
|
|
|
def test_bidirectional_nonce_and_ack_are_required(self):
|
|
configured = self.manager.configure(self.spec, time.monotonic() + 1)
|
|
peer_nonce = configured.local_path / (
|
|
".archive-control-route-nonce.archive-1"
|
|
)
|
|
peer_nonce.write_text(
|
|
json.dumps({
|
|
"route_id": "route-1",
|
|
"client_id": "archive-1",
|
|
"nonce": "peer-nonce",
|
|
}),
|
|
encoding="utf-8",
|
|
)
|
|
acknowledgement = configured.local_path / (
|
|
".archive-control-route-ack.cache-1.archive-1"
|
|
)
|
|
acknowledgement.write_text(
|
|
json.dumps({"route_id": "route-1", "nonce": "local-nonce"}),
|
|
encoding="utf-8",
|
|
)
|
|
verified = self.manager.verify(
|
|
configured,
|
|
self.spec,
|
|
"cache-1",
|
|
"local-nonce",
|
|
time.monotonic() + 1,
|
|
)
|
|
self.assertEqual(verified, (True, True))
|
|
peer_ack = configured.local_path / (
|
|
".archive-control-route-ack.archive-1.cache-1"
|
|
)
|
|
self.assertEqual(json.loads(peer_ack.read_text())["nonce"], "peer-nonce")
|
|
|
|
def test_verification_times_out_without_peer_evidence(self):
|
|
configured = self.manager.configure(self.spec, time.monotonic() + 1)
|
|
with self.assertRaises(RouteSetupTimeout):
|
|
self.manager.verify(
|
|
configured,
|
|
self.spec,
|
|
"cache-1",
|
|
"local-nonce",
|
|
time.monotonic() + 0.01,
|
|
)
|
|
self.assertTrue(self.transport.posts)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|