3 files changed, 133 insertions, 5 deletions

diff --git a/tests/integration/harness.py b/tests/integration/harness.py
index a9d38ca..10aa6de 100644
--- a/tests/integration/harness.py
+++ b/tests/integration/harness.py
@@ -192,7 +192,7 @@ class Tracker:
     def torrent_count(self):
         return int(self.stats("torr").split()[0])
 
-    def livesync_send(self, payload):
+    def livesync_send(self, payload, group=LIVESYNC_GROUP):
         """Put a packet on the live sync group.
 
         It has to go to the group rather than straight at the port: the
@@ -204,7 +204,7 @@ class Tracker:
             sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, socket.inet_aton("127.0.0.1"))
             sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 1)
             sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 1)
-            sock.sendto(payload, (LIVESYNC_GROUP, self.livesync_port))
+            sock.sendto(payload, (group, self.livesync_port))
         finally:
             sock.close()
 
diff --git a/tests/integration/test_config.py b/tests/integration/test_config.py
index 1a84fa7..2f6bdc4 100644
--- a/tests/integration/test_config.py
+++ b/tests/integration/test_config.py
@@ -1,7 +1,9 @@
 """Settings the tracker has to accept, and still work with.
 
-An unrecognised key makes opentracker refuse to start, so a test that it
-comes up at all is a test that the key was understood.
+An unrecognised key only warns, so coming up proves nothing on its own and a
+test that cares has to look at what the tracker said. A key that is
+recognised but cannot be parsed is another matter, and for the listen
+statements it stops the tracker.
 """
 
 import unittest
@@ -14,6 +16,7 @@ class TcpWorkers(TrackerTestCase):
 
     def test_the_tracker_serves_with_tcp_workers_asked_for(self):
         self.assertEqual(self.tracker.announce(self.hash_for("tcpworkers"))[b"complete"], 1)
+        self.assertNotIn("Unhandled line", self.tracker.output())
 
 
 class WorkersOnAListenStatement(unittest.TestCase):
@@ -27,3 +30,22 @@ class WorkersOnAListenStatement(unittest.TestCase):
             self.assertEqual(complaints, [], "the tracker reported:\n" + "\n".join(complaints))
         finally:
             tracker._cleanup()
+
+
+class AListenLineThatDoesNotParse(unittest.TestCase):
+    """Warning and carrying on left a tracker that had been told where to
+    listen coming up on its default instead, which is every interface."""
+
+    def refuses(self, line):
+        with self.assertRaises(AssertionError) as caught:
+            Tracker(line)
+        return str(caught.exception)
+
+    def test_an_address_that_is_not_one_stops_the_tracker(self):
+        self.assertIn("want an address", self.refuses("listen.tcp 10.0.0.300:7999\n"))
+
+    def test_so_does_a_port_out_of_range(self):
+        self.assertIn("want an address", self.refuses("listen.udp 127.0.0.1:99999\n"))
+
+    def test_so_does_an_option_it_does_not_know(self):
+        self.assertIn("want an address", self.refuses("listen.tcp 127.0.0.1:7999 wokers=2\n"))
diff --git a/tests/integration/test_livesync.py b/tests/integration/test_livesync.py
index 8dd754b..f4cb2db 100644
--- a/tests/integration/test_livesync.py
+++ b/tests/integration/test_livesync.py
@@ -10,7 +10,7 @@ import struct
 import subprocess
 import unittest
 
-from harness import TRACKER, TrackerTestCase
+from harness import TRACKER, Tracker, TrackerTestCase
 
 # enum { OT_SYNC_PEER4, OT_SYNC_PEER6 } in src/ot_livesync.c
 SYNC_PEER4 = 0
@@ -102,6 +102,17 @@ class LiveSyncIn(TrackerTestCase):
         self.tracker.livesync_send(packet(99, [(info_hash, peer4("10.1.2.11", 6881, FLAG_SEEDING))]))
         self.assertFalse(self.tracker.wait_until(lambda: self.counts(info_hash) is not None, timeout=1))
 
+    def test_synced_peers_are_counted(self):
+        """The live sync worker keeps its own tally like every other worker,
+        and ?mode=syncs is the sum of them."""
+        before = int(self.tracker.stats("syncs").split()[0])
+        hashes = [self.hash_for("sync-count-%d" % i) for i in range(3)]
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(h, peer4("10.1.2.%d" % (20 + i), 6881, FLAG_SEEDING))
+                                                       for i, h in enumerate(hashes)]))
+        self.assertTrue(self.tracker.wait_until(
+            lambda: int(self.tracker.stats("syncs").split()[0]) == before + 3),
+            "syncs says %s" % self.tracker.stats("syncs").split()[0])
+
     def test_a_packet_with_nothing_but_a_header_is_ignored(self):
         before = self.tracker.torrent_count()
         self.tracker.livesync_send(struct.pack("!I", 0xDEADBEEF) + struct.pack("!I", SYNC_PEER4))
@@ -119,3 +130,98 @@ class LiveSyncAccess(TrackerTestCase):
         info_hash = self.hash_for("sync-unblessed")
         self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.2.12", 6881, FLAG_SEEDING))]))
         self.assertFalse(self.tracker.wait_until(lambda: self.tracker.torrent_count() != 0, timeout=1))
+
+
+@unittest.skipUnless(has_livesync(), "this build has no WANT_SYNC_LIVE")
+class LiveSyncUnconfigured(TrackerTestCase):
+    """A binary that has the feature but no cluster to join. Somebody whose
+    packager turned WANT_SYNC_LIVE on did not ask for live sync and should
+    not be able to tell that it is there."""
+
+    config = ""
+
+    def test_the_tracker_runs_anyway(self):
+        info_hash = self.hash_for("no-cluster")
+        self.tracker.announce(info_hash, port=6881, left=0)
+        self.assertEqual(self.tracker.torrent_count(), 1)
+
+    def test_nothing_is_said_about_the_missing_cluster(self):
+        self.assertNotIn("sync", self.tracker.output().lower())
+
+    def test_no_socket_is_bound_for_it(self):
+        """A configured tracker holds the wildcard address on that port, so
+        taking it here proves nothing was started."""
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            sock.bind(("0.0.0.0", self.tracker.livesync_port))
+        finally:
+            sock.close()
+
+    def test_announcing_stays_clean(self):
+        """Enough announces to pass the watermark that would flush an
+        outgoing buffer, if there were one to flush. The sanitizers in this
+        build turn anything the attempt touched into a failure."""
+        for i in range(200):
+            self.tracker.announce(self.hash_for("no-cluster-%d" % i), port=6881 + i, left=0)
+        self.assertEqual(self.tracker.torrent_count(), 200)
+
+
+# RFC 2365 sets 239.192.0.0/14 aside for exactly this kind of use
+OWN_GROUP = "239.192.0.7"
+# A group nothing in this suite ever joins. Deliberately not the default one:
+# other trackers here do join that, on ports the harness picks at random, and
+# a socket bound to the wildcard address shares a port's multicast traffic
+# with anything else on the host that has joined the group it is addressed
+# to. Two clusters sharing a host and a port is pathological in the field but
+# routine in a test suite.
+UNJOINED_GROUP = "239.192.0.99"
+
+
+@unittest.skipUnless(has_livesync(), "this build has no WANT_SYNC_LIVE")
+class LiveSyncGroup(TrackerTestCase):
+    config = ("livesync.cluster.group %s\n"
+              "livesync.cluster.listen 127.0.0.1:{livesync_port}\n"
+              "livesync.cluster.node_ip 127.0.0.1\n" % OWN_GROUP)
+
+    def test_the_configured_group_is_joined(self):
+        info_hash = self.hash_for("own-group")
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.3.1", 6881, FLAG_SEEDING))]),
+                                   group=OWN_GROUP)
+        self.assertTrue(self.tracker.wait_until(lambda: self.tracker.torrent_count() == 1))
+
+    def test_another_group_is_left_alone(self):
+        """A cluster that picked its own group hears nothing from the others."""
+        info_hash = self.hash_for("not-our-group")
+        self.tracker.livesync_send(packet(SYNC_PEER4, [(info_hash, peer4("10.1.3.2", 6881, FLAG_SEEDING))]),
+                                   group=UNJOINED_GROUP)
+        self.assertFalse(self.tracker.wait_until(lambda: self.tracker.torrent_count() != 0, timeout=1))
+
+
+@unittest.skipUnless(has_livesync(), "this build has no WANT_SYNC_LIVE")
+class LiveSyncGroupRefused(unittest.TestCase):
+    """A cluster that asked for a group of its own must not quietly end up on
+    the one every other opentracker is on, so a line that does not name a
+    group stops the tracker rather than falling back."""
+
+    def start_with(self, group):
+        return Tracker("livesync.cluster.group %s\n"
+                       "livesync.cluster.listen 127.0.0.1:{livesync_port}\n"
+                       "livesync.cluster.node_ip 127.0.0.1\n" % group)
+
+    def test_a_unicast_address_stops_the_tracker(self):
+        with self.assertRaises(AssertionError) as caught:
+            self.start_with("10.0.0.1")
+        self.assertIn("multicast address", str(caught.exception))
+
+    def test_so_does_something_that_is_not_an_address(self):
+        with self.assertRaises(AssertionError) as caught:
+            self.start_with("not-an-address")
+        self.assertIn("multicast address", str(caught.exception))
+
+    def test_a_group_at_either_end_of_the_range_is_taken(self):
+        for group in ("224.0.0.1", "239.255.255.255"):
+            tracker = self.start_with(group)
+            try:
+                self.assertEqual(tracker.torrent_count(), 0)
+            finally:
+                tracker.stop()