test: enable RFC6638 scheduling tests via multi-user docker setups

- Fix config_loader._load_config_file to preserve top-level keys like
  rfc6638_users when unwrapping the test-servers dict — previously they
  were silently dropped, so TestScheduling was always skipped.
- Fix registry.load_from_config to skip non-dict entries (e.g. the
  rfc6638_users list) instead of raising ValueError.
- Add two new tests in test_config_loader.py covering these fixes.
- Add user1/testpass1, user2/testpass2, user3/testpass3 to the Baikal
  pre-seeded SQLite DB (create_baikal_db.py + regenerated db.sqlite),
  alongside the existing testuser account.
- Add user1-user3 to init-sogo-users.sql for SOGo.
- Add CI step that writes tests/caldav_test_servers.yaml with
  rfc6638_users pointing to Cyrus user1-user3 (password 'x'), which
  are pre-created by the ghcr.io/cyrusimap/cyrus-docker-test-server
  image and are expected to support calendar-auto-schedule.
- Update example config files with server-specific rfc6638_users
  snippets for Cyrus, Baikal and SOGo.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: tobixen

.github/workflows/tests.yaml

@@ -276,6 +276,26 @@ jobs:
             echo "✗ Error: Bedework CalDAV access failed"
             exit 1
           fi
+      - name: Configure RFC6638 scheduling test users
+        run: |
+          # Write test config with rfc6638_users for scheduling tests.
+          # Cyrus pre-creates user1-user5 (password 'x') with scheduling support.
+          # Baikal users user1-user3 are in the pre-seeded db.sqlite.
+          # Two separate config sections for each server; CI uses Cyrus.
+          cat > tests/caldav_test_servers.yaml << 'EOF'
+          # RFC6638 scheduling test users - written by CI
+          # Cyrus pre-creates user1-user5 with password 'x' and supports scheduling
+          rfc6638_users:
+            - url: http://localhost:8802/dav/calendars/user/user1
+              username: user1
+              password: x
+            - url: http://localhost:8802/dav/calendars/user/user2
+              username: user2
+              password: x
+            - url: http://localhost:8802/dav/calendars/user/user3
+              username: user3
+              password: x
+          EOF
       - run: tox -e py
         env:
           NEXTCLOUD_URL: http://localhost:8801

tests/caldav_test_servers.yaml.example

@@ -150,13 +150,42 @@ test-servers:
 # RFC6638 scheduling test users (optional)
 # =========================================================================
 #
-# For testing calendar scheduling (meeting invites, etc.), define
-# multiple users that can send invites to each other:
-
+# For testing calendar scheduling (meeting invites, etc.), define at least
+# three users on the same CalDAV server that can send invites to each other.
+# This section lives at the TOP LEVEL (not under test-servers).
+#
+# Cyrus (pre-creates user1-user5 with password 'x'):
+# rfc6638_users:
+#   - url: http://localhost:8802/dav/calendars/user/user1
+#     username: user1
+#     password: x
+#   - url: http://localhost:8802/dav/calendars/user/user2
+#     username: user2
+#     password: x
+#   - url: http://localhost:8802/dav/calendars/user/user3
+#     username: user3
+#     password: x
+#
+# Baikal (user1-user3 are in the pre-seeded db.sqlite, passwords testpass1-3):
+# rfc6638_users:
+#   - url: http://localhost:8800/dav.php/
+#     username: user1
+#     password: testpass1
+#   - url: http://localhost:8800/dav.php/
+#     username: user2
+#     password: testpass2
+#   - url: http://localhost:8800/dav.php/
+#     username: user3
+#     password: testpass3
+#
+# SOGo (user1-user3 from init-sogo-users.sql, passwords testpass1-3):
 # rfc6638_users:
-#   - url: https://caldav.example.com/dav/user1/
+#   - url: http://localhost:8803/SOGo/dav/user1
 #     username: user1
-#     password: pass1
-#   - url: https://caldav.example.com/dav/user2/
+#     password: testpass1
+#   - url: http://localhost:8803/SOGo/dav/user2
 #     username: user2
-#     password: pass2
+#     password: testpass2
+#   - url: http://localhost:8803/SOGo/dav/user3
+#     username: user3
+#     password: testpass3

tests/docker-test-servers/baikal/Specific/db/db.sqlite

@@ -232,6 +232,47 @@ def create_baikal_db(db_path: Path, username: str = "testuser", password: str =
     print(f"  Digest A1: {ha1}")
 
 
+def add_baikal_user(db_path: Path, username: str, password: str) -> None:
+    """Add an additional user to an existing Baikal SQLite database."""
+    realm = "BaikalDAV"
+    ha1 = hashlib.md5(f"{username}:{realm}:{password}".encode()).hexdigest()
+    principal_uri = f"principals/{username}"
+
+    conn = sqlite3.connect(str(db_path))
+    cursor = conn.cursor()
+
+    cursor.execute("INSERT OR REPLACE INTO users (username, digesta1) VALUES (?, ?)", (username, ha1))
+
+    cursor.execute(
+        "INSERT OR IGNORE INTO principals (uri, email, displayname) VALUES (?, ?, ?)",
+        (principal_uri, f"{username}@baikal.test", f"Test User ({username})"),
+    )
+
+    cursor.execute(
+        "INSERT INTO calendars (synctoken, components) VALUES (?, ?)",
+        (1, "VEVENT,VTODO,VJOURNAL"),
+    )
+    calendar_id = cursor.lastrowid
+
+    cursor.execute(
+        """INSERT INTO calendarinstances
+           (calendarid, principaluri, access, displayname, uri, calendarorder, calendarcolor)
+           VALUES (?, ?, ?, ?, ?, ?, ?)""",
+        (calendar_id, principal_uri, 1, "Default Calendar", "default", 0, "#3a87ad"),
+    )
+
+    cursor.execute(
+        """INSERT INTO addressbooks
+           (principaluri, displayname, uri, synctoken)
+           VALUES (?, ?, ?, ?)""",
+        (principal_uri, "Default Address Book", "default", 1),
+    )
+
+    conn.commit()
+    conn.close()
+    print(f"✓ Added user '{username}' to Baikal database")
+
+
 def create_baikal_config(config_path: Path) -> None:
     """Create Baikal config.php file."""
 
@@ -358,10 +399,14 @@ def create_baikal_yaml(yaml_path: Path) -> None:
 if __name__ == "__main__":
     script_dir = Path(__file__).parent
 
-    # Create database
+    # Create database with primary test user
     db_path = script_dir / "Specific" / "db" / "db.sqlite"
     create_baikal_db(db_path, username="testuser", password="testpass")
 
+    # Add extra users for RFC6638 scheduling tests (need at least 3)
+    for i in range(1, 4):
+        add_baikal_user(db_path, username=f"user{i}", password=f"testpass{i}")
+
     # Create legacy PHP config files (for older Baikal versions)
     config_path = script_dir / "Specific" / "config.php"
     create_baikal_config(config_path)
@@ -380,4 +425,5 @@ def create_baikal_yaml(yaml_path: Path) -> None:
     print("\nCredentials:")
     print("  Admin: admin / admin")
     print("  User: testuser / testpass")
+    print("  RFC6638 users: user1/testpass1, user2/testpass2, user3/testpass3")
     print("  CalDAV URL: http://localhost:8800/dav.php/")

tests/docker-test-servers/baikal/create_baikal_db.py

@@ -14,3 +14,16 @@ CREATE TABLE IF NOT EXISTS sogo_users (
 INSERT INTO sogo_users (c_uid, c_name, c_password, c_cn, mail)
 VALUES ('testuser', 'testuser', MD5('testpass'), 'Test User', 'testuser@example.com')
 ON DUPLICATE KEY UPDATE c_password=MD5('testpass');
+
+-- Additional users for RFC6638 scheduling tests (need at least 3 users)
+INSERT INTO sogo_users (c_uid, c_name, c_password, c_cn, mail)
+VALUES ('user1', 'user1', MD5('testpass1'), 'Test User 1', 'user1@example.com')
+ON DUPLICATE KEY UPDATE c_password=MD5('testpass1');
+
+INSERT INTO sogo_users (c_uid, c_name, c_password, c_cn, mail)
+VALUES ('user2', 'user2', MD5('testpass2'), 'Test User 2', 'user2@example.com')
+ON DUPLICATE KEY UPDATE c_password=MD5('testpass2');
+
+INSERT INTO sogo_users (c_uid, c_name, c_password, c_cn, mail)
+VALUES ('user3', 'user3', MD5('testpass3'), 'Test User 3', 'user3@example.com')
+ON DUPLICATE KEY UPDATE c_password=MD5('testpass3');

tests/docker-test-servers/sogo/init-sogo-users.sql

@@ -109,13 +109,30 @@ test-servers:
 # RFC6638 scheduling test users (optional)
 # =========================================================================
 #
-# For testing calendar scheduling (meeting invites, etc.), define
-# multiple users that can send invites to each other:
-
+# For testing calendar scheduling (meeting invites, etc.), define at least
+# three users on the same CalDAV server that can send invites to each other.
+# This section lives at the TOP LEVEL (not under test-servers).
+#
+# Cyrus (pre-creates user1-user5 with password 'x'):
+# rfc6638_users:
+#   - url: http://localhost:8802/dav/calendars/user/user1
+#     username: user1
+#     password: x
+#   - url: http://localhost:8802/dav/calendars/user/user2
+#     username: user2
+#     password: x
+#   - url: http://localhost:8802/dav/calendars/user/user3
+#     username: user3
+#     password: x
+#
+# Baikal (user1-user3 are in the pre-seeded db.sqlite, passwords testpass1-3):
 # rfc6638_users:
-#   - url: https://caldav.example.com/dav/user1/
+#   - url: http://localhost:8800/dav.php/
 #     username: user1
-#     password: pass1
-#   - url: https://caldav.example.com/dav/user2/
+#     password: testpass1
+#   - url: http://localhost:8800/dav.php/
 #     username: user2
-#     password: pass2
+#     password: testpass2
+#   - url: http://localhost:8800/dav.php/
+#     username: user3
+#     password: testpass3

tests/test_servers.yaml.example

@@ -91,7 +91,11 @@ def _load_config_file(path: str) -> dict[str, dict[str, Any]]:
     # Unwrap the "test-servers" key if present (the example YAML
     # uses this as a top-level namespace).  Also support configs
     # where server dicts are at the top level directly.
+    # Preserve top-level non-server keys (e.g. rfc6638_users) by merging
+    # them back into the servers dict after unwrapping.
     if "test-servers" in cfg:
+        top_level_extras = {k: v for k, v in cfg.items() if k != "test-servers"}
         cfg = cfg["test-servers"]
+        cfg.update(top_level_extras)
 
     return cfg

tests/test_servers/config_loader.py

@@ -183,10 +183,8 @@ def load_from_config(self, config: dict) -> None:
 
         for name, server_config in config.items():
             if not isinstance(server_config, dict):
-                raise ValueError(
-                    f"Server '{name}': configuration must be a dict, "
-                    f"got {type(server_config).__name__}"
-                )
+                # Skip non-server entries (e.g. rfc6638_users is a list, not a server)
+                continue
 
             if not server_config.get("enabled", True):
                 continue

tests/test_servers/registry.py

@@ -88,3 +88,39 @@ def test_empty_yaml_raises_error(self, tmp_path: Path) -> None:
         with pytest.raises(ConfigParseError) as exc_info:
             load_test_server_config(str(config_file))
         assert "could not be parsed" in str(exc_info.value)
+
+    def test_rfc6638_users_preserved_alongside_test_servers(self, tmp_path: Path) -> None:
+        """rfc6638_users at top level is preserved when test-servers is unwrapped."""
+        config_file = tmp_path / "test_servers.yaml"
+        config_file.write_text("""
+test-servers:
+  radicale:
+    type: embedded
+    enabled: true
+
+rfc6638_users:
+  - url: http://localhost:8802/dav/calendars/user/user1
+    username: user1
+    password: x
+  - url: http://localhost:8802/dav/calendars/user/user2
+    username: user2
+    password: x
+""")
+        cfg = load_test_server_config(str(config_file))
+        assert "radicale" in cfg
+        assert "rfc6638_users" in cfg
+        assert len(cfg["rfc6638_users"]) == 2
+        assert cfg["rfc6638_users"][0]["username"] == "user1"
+
+    def test_rfc6638_users_only_config(self, tmp_path: Path) -> None:
+        """Config with only rfc6638_users (no test-servers) works correctly."""
+        config_file = tmp_path / "test_servers.yaml"
+        config_file.write_text("""
+rfc6638_users:
+  - url: http://localhost:8802/dav/calendars/user/user1
+    username: user1
+    password: x
+""")
+        cfg = load_test_server_config(str(config_file))
+        assert "rfc6638_users" in cfg
+        assert cfg["rfc6638_users"][0]["url"] == "http://localhost:8802/dav/calendars/user/user1"