From c05fc432eb4734c3b898ec4b70d987a8c647f568 Mon Sep 17 00:00:00 2001
From: Laurent Chedanne <git@chedanne.pro>
Date: Thu, 15 Oct 2026 15:19:23 +0200
Subject: [PATCH] Export caldav with logs

---
 .gitignore                    |   1 +
 AGENTS.md                     |  28 +++
 crealead-caldav.py            | 257 +++++++++++++++++++-----
 docs/crealead-caldav.md       | 235 ++++++++++++++++++++++
 tests/test_crealead_caldav.py | 364 ++++++++++++++++++++++++++++++++++
 5 files changed, 836 insertions(+), 49 deletions(-)
 create mode 100644 AGENTS.md
 create mode 100644 docs/crealead-caldav.md
 create mode 100644 tests/test_crealead_caldav.py

diff --git a/.gitignore b/.gitignore
index ad6dd79..3d361b6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,4 @@ env/*
 config.json
 config.json.*
 csv/*
+logs/
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..d052a2a
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,28 @@
+# Consignes de maintenance
+
+- Mettre à jour `docs/crealead-caldav.md` lors de toute évolution impactant
+  `crealead-caldav.py`, notamment ses pré-requis, sa configuration, son
+  lancement, le traitement des événements, ses sorties CSV, sa journalisation
+  ou ses tests dans `tests/`.
+- Garder les exemples de configuration, les commandes d'exécution et les cas
+  de test documentés cohérents avec le comportement du script.
+- Chaque nouvelle ligne écrite dans `logs/crealead-caldav.log` doit commencer
+  par l'heure d'écriture en UTC au format ISO 8601 avec suffixe `Z`, entre
+  crochets. Le format par défaut est :
+  `[2026-10-15T12:34:56Z]: [info] - message`.
+  Cela s'applique aux sorties standard et d'erreur ainsi qu'aux lignes des
+  traces d'exception.
+- Tout événement non exporté doit laisser une trace au format
+  `[2026-10-15T12:34:56Z]: [warning][event] - message`, sans préfixe `[info]`
+  supplémentaire. Préciser le calendrier concerné, le titre, le moment de
+  l'événement (début et fin disponibles) et la raison de son exclusion.
+  Ajouter le fichier CSV et l'UID pour faciliter son identification.
+- Ne jamais ignorer silencieusement un événement, notamment en cas de
+  `SUMMARY` absent, de dates absentes ou invalides, de document iCalendar
+  illisible ou d'export CSV interrompu. Récupérer les métadonnées disponibles
+  dans les données brutes si nécessaire et indiquer `indisponible` pour celles
+  qui ne peuvent pas être retrouvées. Échapper les retours à la ligne des
+  métadonnées et du motif pour conserver un avertissement sur une seule ligne.
+- Lors d'une évolution du traitement des événements ou de la journalisation,
+  vérifier dans les tests que les événements écartés sont bien tracés avec les
+  informations et les préfixes ci-dessus.
diff --git a/crealead-caldav.py b/crealead-caldav.py
index 764060e..4e75067 100644
--- a/crealead-caldav.py
+++ b/crealead-caldav.py
@@ -17,11 +17,144 @@ import sys
 import caldav
 import json
 import csv
-import calendar
-from datetime import date, datetime, timezone
+from datetime import date, datetime, time, timezone
+from icalendar import Calendar
 import pytz
 from urllib.parse import unquote
 import re
+import traceback
+from contextlib import contextmanager, redirect_stdout, redirect_stderr
+from pathlib import Path
+
+
+def utc_timestamp():
+  return datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
+
+
+class TimestampedLog:
+  """Prefix each log line, including lines written in several fragments."""
+
+  def __init__(self, log_file):
+    self.log_file = log_file
+    self.line_start = True
+
+  def write(self, value):
+    # Keep an event warning separate from an unfinished console message.
+    if value.startswith('[warning][event] - ') and not self.line_start:
+      self.log_file.write('\n')
+      self.line_start = True
+    for fragment in value.splitlines(keepends=True):
+      if self.line_start:
+        self.log_file.write('[{}]: '.format(utc_timestamp()))
+        if not fragment.startswith('[warning][event] - '):
+          self.log_file.write('[info] - ')
+      self.log_file.write(fragment)
+      self.line_start = fragment.endswith(('\n', '\r'))
+    return len(value)
+
+  def flush(self):
+    self.log_file.flush()
+
+
+class TeeOutput:
+  """Write to the original console stream and to the shared log file."""
+
+  def __init__(self, stream, log_file):
+    self.stream = stream
+    self.log_file = log_file
+
+  def write(self, value):
+    written = self.stream.write(value)
+    self.log_file.write(value)
+    self.log_file.flush()
+    return written
+
+  def flush(self):
+    self.stream.flush()
+    self.log_file.flush()
+
+  def __getattr__(self, name):
+    return getattr(self.stream, name)
+
+
+@contextmanager
+def log_output():
+  """Append console output to logs/<script name>.log next to the script."""
+  script_path = Path(__file__).resolve()
+  log_path = script_path.parent / 'logs' / script_path.with_suffix('.log').name
+  log_path.parent.mkdir(parents=True, exist_ok=True)
+  with log_path.open('a', encoding='utf-8') as log_file:
+    log_writer = TimestampedLog(log_file)
+    with redirect_stdout(TeeOutput(sys.stdout, log_writer)), \
+         redirect_stderr(TeeOutput(sys.stderr, log_writer)):
+      try:
+        yield
+      except BaseException as error:
+        # The interpreter prints the traceback after the streams are restored.
+        # Save a copy here while the log is still open, without duplicating it
+        # in the console. SystemExit normally has no traceback.
+        if not log_writer.line_start:
+          log_writer.write('\n')
+        if isinstance(error, SystemExit):
+          if error.code is not None and not isinstance(error.code, int):
+            log_writer.write(str(error.code) + '\n')
+        else:
+          traceback.print_exc(file=log_writer)
+        raise
+      finally:
+        if not log_writer.line_start:
+          log_writer.write('\n')
+
+
+def recover_event_contexts(data):
+  """Recover identifying fields even when the iCalendar parser rejects data."""
+  if isinstance(data, bytes):
+    data = data.decode('utf-8', errors='replace')
+  unfolded = re.sub(r'\r?\n[ \t]', '', str(data))
+  blocks = re.split(r'(?im)^BEGIN:VEVENT\s*\r?$', unfolded)
+  contexts = []
+  for block in blocks[1:] or [unfolded]:
+    context = {}
+    depth = 0
+    for line in block.splitlines():
+      name, separator, value = line.partition(':')
+      name = name.split(';', 1)[0].upper()
+      if name == 'BEGIN':
+        depth += 1
+      elif name == 'END':
+        if depth == 0:
+          break
+        depth -= 1
+      elif depth == 0 and separator and name in ('SUMMARY', 'DTSTART', 'DTEND', 'UID'):
+        context.setdefault(name, value)
+    contexts.append(context)
+  return contexts
+
+
+def log_skipped_event(calendar_find, component, reason, fallback=None):
+  """Every rejected event must have an identifiable warning in the log."""
+  fallback = fallback or {}
+
+  def field(name):
+    value = component.get(name)
+    if value is None:
+      return str(fallback.get(name, 'indisponible'))
+    decoded = getattr(value, 'dt', None)
+    if isinstance(decoded, datetime):
+      return local_datetime(decoded).astimezone(timezone.utc).isoformat().replace('+00:00', 'Z')
+    if isinstance(decoded, date):
+      return decoded.isoformat()
+    return str(value)
+
+  calendar_name = getattr(calendar_find.get('calendar_server'), 'name', None)
+  calendar_name = calendar_name or calendar_find.get('calendar_name', 'indisponible')
+  # repr keeps newlines in event metadata from breaking the warning format.
+  print('[warning][event] - Calendrier={!r} ; CSV={!r} ; titre={!r} ; '
+        'début={!r} ; fin={!r} ; UID={!r} ; événement non exporté : {}'.format(
+    str(calendar_name), calendar_find['csv_name'], field('SUMMARY'),
+    field('DTSTART'), field('DTEND'), field('UID'),
+    str(reason).replace('\r', '\\r').replace('\n', '\\n')), file=sys.stderr)
+
 
 class EventRow():
 
@@ -34,6 +167,7 @@ class EventRow():
     self.categories = ''
     self.location = ''
     self.description = ''
+    self.event_context = {}
 
   def set_title(self, title):
     self.title = title
@@ -111,21 +245,18 @@ def link_calendars(config, calendars_server):
   return calendars_find
 
 
-def split_data(data):
-  """Return string splitted by ';' separator"""
-  return data.split(':')
-
-
-def datetime_format(date_str):
-  """Return date formated"""
-  try: # Nextcloud Format
-   date_formated = datetime.strptime(date_str, '%Y%m%dT%H%M%SZ')
-  except: # Zimbra format
-   date_formated = datetime.strptime(date_str, '%Y%m%d')
+def local_datetime(value):
+  """Convert an iCalendar date or datetime to Europe/Paris."""
   paris_tz = pytz.timezone('Europe/Paris')
-  date_formated = date_formated.replace(tzinfo=timezone.utc).astimezone(paris_tz)
-  #date_formated = date_formated.astimezone(paris_tz)
-  return date_formated
+  if isinstance(value, datetime):
+    result = value
+  elif isinstance(value, date):
+    result = datetime.combine(value, time.min)
+  else:
+    raise ValueError("date absente ou invalide")
+  if result.tzinfo is None:
+    return paris_tz.localize(result)
+  return result.astimezone(paris_tz)
 
 
 def get_all_events(config, calendars_find):
@@ -142,40 +273,56 @@ def get_all_events(config, calendars_find):
     event_rows = []
   
     for event in events_fetched:
-      event_fields = list(map(split_data, event.data.splitlines()))
+      contexts = recover_event_contexts(event.data)
+      # Parse parameters (TZID, VALUE=DATE), folded lines and escaped text.
+      try:
+        event_calendar = Calendar.from_ical(event.data)
+      except (ValueError, TypeError) as error:
+        for context in contexts:
+          log_skipped_event(calendar_find, {},
+            'document iCalendar illisible ({})'.format(error), context)
+        continue
 
-      # Fix problem #2023022110004936
-      has = False 
-      for sub in event_fields:
-          if 'SUMMARY' in sub:
-              has = True
-              break
-      if not has:
-          continue 
+      components = event_calendar.walk('VEVENT')
+      if not components:
+        log_skipped_event(calendar_find, {}, 'aucun composant VEVENT', contexts[0])
 
-      event_row = EventRow()
+      for index, component in enumerate(components):
+        context = contexts[index] if index < len(contexts) else {}
+        # Fix problem #2023022110004936: ignore events without a summary.
+        if 'SUMMARY' not in component:
+          log_skipped_event(calendar_find, component, 'propriété SUMMARY absente', context)
+          continue
 
-      for field in ['SUMMARY', 'DTSTART', 'DTEND', 'CATEGORIES', 'LOCATION', 'DESCRIPTION']:
-        for event_field in event_fields:
-          if field == event_field[0]:
-            if field == "SUMMARY":
-              event_row.set_title(event_field[1])
-            elif field == "DTSTART":
-              date = datetime_format(event_field[1])
-              event_row.set_start(date)
-            elif field == "DTEND":
-              date = datetime_format(event_field[1])
-              event_row.set_end(date)
-            elif field == "CATEGORIES":
-              event_row.set_categories(event_field[1])
-            elif field == "LOCATION":
-              event_row.set_location(event_field[1])
-            elif field == "DESCRIPTION":
-              event_row.set_description(clean_description(event_field[1]))
-      event_rows.append(event_row)
+        try:
+          start = component.decoded('DTSTART')
+          end = component.decoded('DTEND', None)
+          if end is None and 'DURATION' in component:
+            end = start + component.decoded('DURATION')
+          start = local_datetime(start)
+          end = local_datetime(end)
+        except (KeyError, ValueError, TypeError) as error:
+          log_skipped_event(calendar_find, component,
+            'dates de début/fin absentes ou invalides ({})'.format(error), context)
+          continue
 
-    sorted_rows = sorted(event_rows, key=lambda l: datetime.strptime(str(l.start_date)+'T'+str(l.start_time), "%Y-%m-%dT%H:%M:%S"))
+        event_row = EventRow()
+        event_row.event_context = component
+        event_row.set_title(str(component['SUMMARY']))
+        event_row.set_start(start)
+        event_row.set_end(end)
+        categories = component.get('CATEGORIES', [])
+        if not isinstance(categories, list):
+          categories = [categories]
+        event_row.set_categories(','.join(
+          str(category) for group in categories for category in group.cats))
+        event_row.set_location(str(component.get('LOCATION', '')))
+        event_row.set_description(clean_description(str(component.get('DESCRIPTION', ''))))
+        event_rows.append(event_row)
+
+    sorted_rows = sorted(event_rows, key=lambda row: (row.start_date, row.start_time))
     calendars_to_write.append({'csv_name' : calendar_find['csv_name'],
+                               'calendar' : calendar_find,
                                'line' : sorted_rows})
 
   return calendars_to_write
@@ -197,8 +344,7 @@ def write_csv(filename, rows):
       writer.writerow(row.get_csv_row())
 
 
-if __name__ == "__main__":
-
+def main():
   # Load config
   config = load_json_config("./config.json")
 
@@ -212,5 +358,18 @@ if __name__ == "__main__":
   calendars_to_write = get_all_events(config, calendars_find)
 
   # Write CSV
-  for calendar_to_write in calendars_to_write:
-    write_csv(calendar_to_write['csv_name'], calendar_to_write['line'])
+  for index, calendar_to_write in enumerate(calendars_to_write):
+    try:
+      write_csv(calendar_to_write['csv_name'], calendar_to_write['line'])
+    except Exception as error:
+      # The current CSV may be incomplete; later calendars were not written.
+      for pending in calendars_to_write[index:]:
+        for row in pending['line']:
+          log_skipped_event(pending['calendar'], row.event_context,
+            'export CSV interrompu, écriture non garantie ({})'.format(error))
+      raise
+
+
+if __name__ == "__main__":
+  with log_output():
+    main()
diff --git a/docs/crealead-caldav.md b/docs/crealead-caldav.md
new file mode 100644
index 0000000..77e0d43
--- /dev/null
+++ b/docs/crealead-caldav.md
@@ -0,0 +1,235 @@
+# Export CalDAV vers CSV
+
+Le script [`crealead-caldav.py`](../crealead-caldav.py) récupère des événements
+d'agendas accessibles en CalDAV, notamment Nextcloud, et produit un fichier CSV
+par calendrier configuré. Ces fichiers peuvent ensuite être utilisés par
+`csv-to-timemanager.py`.
+
+## Pré-requis
+
+- Python 3, avec `pip` et le module `venv`. L'environnement Docker du dépôt
+  utilise Python 3.9.2.
+- Les dépendances de [`requirements.txt`](../requirements.txt), notamment
+  `caldav`, `icalendar` et `pytz`.
+- Un serveur CalDAV accessible depuis la machine d'exécution et un compte
+  autorisé à lire les calendriers à exporter.
+- Des droits de lecture sur `config.json` et d'écriture sur les fichiers CSV
+  ainsi que sur le dossier `logs/`, situé à côté du script.
+- Bash pour utiliser le lanceur `exec-export-caldav.sh`.
+
+Depuis la racine du dépôt, préparer l'environnement :
+
+```bash
+python3 -m venv env
+source env/bin/activate
+python -m pip install -r requirements.txt
+```
+
+L'environnement Docker fourni constitue une autre façon d'exécuter le script
+et les tests. Sa construction est décrite dans
+[`support/docker-dev/README.md`](../support/docker-dev/README.md).
+
+## Usage
+
+### Configuration minimale
+
+Créer un fichier `config.json` à la racine du dépôt. Exemple pour exporter les
+événements d'octobre 2026 :
+
+```json
+{
+  "caldav_url": "https://cloud.example.com/remote.php/dav/",
+  "username": "utilisateur",
+  "password": "mot-de-passe-application",
+  "year_start": 2026,
+  "month_start": 10,
+  "day_start": 1,
+  "year_end": 2026,
+  "month_end": 11,
+  "day_end": 1,
+  "calendars": [
+    {
+      "calendar_name": "Temps de travail",
+      "csv_name": "csv/utilisateur.csv"
+    }
+  ]
+}
+```
+
+| Champ | Rôle |
+| --- | --- |
+| `caldav_url` | URL du serveur CalDAV. |
+| `username`, `password` | Identifiants du compte qui peut lire les calendriers. |
+| `year_start`, `month_start`, `day_start` | Date de début de la recherche, à minuit. Les valeurs sont des nombres entiers. |
+| `year_end`, `month_end`, `day_end` | Date de fin de la recherche, à minuit. Pour couvrir un mois, utiliser le premier jour du mois suivant. |
+| `calendars` | Liste des calendriers à exporter. |
+| `calendars[].calendar_name` | Texte contenu dans le nom du calendrier distant, avec respect de la casse. Il doit correspondre à un seul calendrier. |
+| `calendars[].csv_name` | Chemin du fichier CSV à écrire. Un chemin relatif est résolu depuis le répertoire de lancement. |
+
+Ajouter une entrée dans `calendars` pour chaque calendrier à exporter.
+Les champs `db_*`, `user_name` et `api_password`, utilisés par d'autres scripts
+du dépôt, ne sont pas nécessaires à cet export.
+
+`config.json` est ignoré par Git. Remplacer les valeurs d'exemple par les
+informations du serveur et du compte utilisés.
+
+### Lancement
+
+Lancer les commandes depuis la racine du dépôt : le script lit
+`./config.json`, et le lanceur recherche `env/bin/activate` dans le répertoire
+courant. Créer au préalable les dossiers de destination des CSV ; le script
+ne les crée pas.
+
+```bash
+mkdir -p csv
+bash ./exec-export-caldav.sh
+```
+
+Le lanceur active l'environnement `env/`, puis exécute le script. Il est aussi
+possible de lancer directement Python :
+
+```bash
+env/bin/python crealead-caldav.py
+```
+
+Le script ne propose pas d'arguments en ligne de commande. La période et les
+calendriers sont définis dans `config.json`.
+
+### Fichiers produits et traitement des événements
+
+Chaque CSV existant est remplacé lors de l'export. Les lignes sont triées par
+date et heure de début. Le séparateur est `;` et les colonnes sont :
+
+```text
+Titre;Date debut;Heure debut;Date fin;Heure fin;Categories;Emplacement;Description
+```
+
+Les événements récurrents sont demandés au serveur avec `expand=True`.
+Le lecteur iCalendar prend en charge les paramètres des propriétés, comme
+`TZID` et `VALUE=DATE`, ainsi que les textes répartis sur plusieurs lignes.
+Les heures sont converties vers `Europe/Paris`. Une heure sans fuseau est
+interprétée dans ce fuseau ; une date seule est exportée à minuit.
+Si `DTEND` est absent, `DURATION` peut fournir la date de fin.
+
+Les événements sans propriété `SUMMARY` sont ignorés. Ceux dont les dates
+de début ou de fin sont absentes ou invalides sont également ignorés. Chaque
+exclusion laisse un avertissement détaillé dans le journal, y compris en
+l'absence de `SUMMARY`. Un document iCalendar illisible ou une ressource sans
+composant `VEVENT` est signalé puis ignoré. Les autres événements restent
+exportés. Si un calendrier configuré est introuvable ou correspond à plusieurs
+calendriers distants, le script affiche un message et s'arrête avant l'écriture
+des CSV.
+
+En cas d'erreur d'écriture d'un CSV, le script s'arrête avec une exception.
+Il laisse un avertissement pour chaque événement du calendrier en cours,
+dont le fichier peut être incomplet, et des calendriers restant à écrire.
+Les fichiers déjà écrits avec succès sont conservés.
+
+### Journalisation
+
+Les sorties standard et d'erreur sont affichées dans le terminal et copiées
+dans `logs/crealead-caldav.log`, à côté du script. Le dossier est créé
+automatiquement. Le journal utilise UTF-8, conserve les exécutions précédentes
+et enregistre les traces d'exception en cas de plantage pendant le traitement.
+Il n'y a pas de rotation automatique du journal. `logs/` est ignoré par Git.
+
+Chaque nouvelle ligne du journal est préfixée par l'heure d'écriture en UTC,
+au format ISO 8601 `YYYY-MM-DDTHH:MM:SSZ`, puis par `[info]` :
+
+```text
+[2026-10-15T12:34:56Z]: [info] - csv/utilisateur.csv ...
+```
+
+Cela s'applique aussi aux messages écrits en plusieurs fragments et à chaque
+ligne d'une trace d'exception. L'horodatage est ajouté dans le fichier de
+journal, sans modifier les messages ordinaires du terminal.
+
+Tout événement non exporté est signalé avec `[warning][event]`, à la place de
+`[info]`. Le message indique le calendrier distant (ou son nom configuré),
+le fichier CSV, le titre, le début, la fin, l'UID et la raison de l'exclusion :
+
+```text
+[2026-10-15T12:34:56Z]: [warning][event] - Calendrier='Temps de travail' ; CSV='csv/utilisateur.csv' ; titre='Réunion' ; début='2026-10-15T08:00:00Z' ; fin='indisponible' ; UID='reunion-1' ; événement non exporté : dates de début/fin absentes ou invalides (date absente ou invalide)
+```
+
+L'heure entre crochets est celle du message ; les champs `début` et `fin`
+décrivent le moment de l'événement. Les dates et heures décodées sont affichées
+en UTC, les dates de journée entière restent des dates seules. En cas de
+document illisible ou de date invalide, le script récupère les champs bruts
+disponibles. Une métadonnée absente ou irrécupérable vaut `indisponible`.
+Les retours à la ligne dans les métadonnées et le motif sont échappés pour
+garder un avertissement sur une seule ligne. Ces avertissements sont aussi
+visibles dans le terminal.
+
+## Tests
+
+Les tests se trouvent dans
+[`tests/test_crealead_caldav.py`](../tests/test_crealead_caldav.py) et utilisent
+`unittest`, fourni avec Python. Aucune dépendance de test supplémentaire
+n'est nécessaire.
+
+### Cas couverts
+
+Les 13 tests de `ExportEventsTests` vérifient :
+
+- La lecture de `DTSTART` et `DTEND` avec `TZID`, leur conversion vers Paris
+  et le tri chronologique des lignes.
+- La conversion des dates UTC en été et en hiver, ainsi que celle d'un autre
+  fuseau horaire.
+- Les événements sur une journée entière (`VALUE=DATE`), les heures sans
+  fuseau et le calcul de la fin à partir de `DURATION`.
+- L'exclusion des événements sans propriété `SUMMARY`, des dates manquantes
+  ou invalides et des documents iCalendar illisibles, sans bloquer les
+  événements valides, ainsi que la présence d'un avertissement contextualisé
+  dans le journal pour chaque événement écarté.
+- La récupération des métadonnées de chaque événement dans un document
+  illisible, la conservation d'une date brute invalide et le signalement
+  d'une ressource sans composant `VEVENT`.
+- La conservation des deux-points dans les textes, des paramètres de texte,
+  des catégories et des lignes repliées, ainsi que le nettoyage de la
+  description HTML encodée et le contenu du CSV écrit.
+
+Les 9 tests de `LogOutputTests` vérifient :
+
+- La création de `logs/` à côté du script, la copie des deux sorties et
+  l'écriture immédiate des messages, y compris les accents.
+- L'ajout au journal existant et le choix du nom du journal d'après celui du
+  script, y compris lorsqu'une exécution se termine sans retour à la ligne.
+- L'horodatage en UTC, le préfixe `[info]` de chaque ligne, les écritures en
+  plusieurs fragments, les messages sur plusieurs lignes et les lignes vides.
+- Le préfixe `[warning][event]` sans `[info]`, les métadonnées de l'événement,
+  l'échappement des retours à la ligne et la séparation d'un avertissement
+  après un message ordinaire inachevé.
+- La sauvegarde des traces d'exception et la restauration des sorties après
+  une erreur.
+- La conservation du code de sortie d'un `SystemExit`, sans ajouter de trace
+  d'exception, et la sauvegarde de son éventuel message.
+
+Le test de `ExportFailureTests` provoque une erreur d'écriture CSV. Il vérifie
+qu'un avertissement est enregistré pour les événements du calendrier en
+échec et des calendriers restant à écrire, et que le premier CSV déjà écrit
+est conservé.
+
+Ces tests utilisent le vrai lecteur `icalendar`, des événements synthétiques
+et des dossiers temporaires pour les CSV et les journaux. Le module CalDAV
+et les réponses du serveur sont simulés : aucun accès réseau, compte,
+`config.json` ou calendrier réel n'est nécessaire. Ils vérifient que la
+recherche demande `expand=True`, mais ne valident pas l'expansion des
+récurrences par un serveur réel ni l'import dans TimeManager.
+
+### Exécution
+
+Depuis la racine du dépôt, avec les dépendances installées dans `env/` :
+
+```bash
+env/bin/python -B -m unittest discover -s tests -v
+```
+
+L'option `-B` évite de créer des fichiers de cache Python. La suite contient
+actuellement 23 tests ; une exécution réussie se termine par `OK`.
+
+Avec l'image Docker du dépôt déjà construite :
+
+```bash
+docker run --rm -v "$(pwd)":/app -w /app cal-to-time-manager:dev -B -m unittest discover -s tests -v
+```
diff --git a/tests/test_crealead_caldav.py b/tests/test_crealead_caldav.py
new file mode 100644
index 0000000..bf79ebf
--- /dev/null
+++ b/tests/test_crealead_caldav.py
@@ -0,0 +1,364 @@
+import contextlib
+import csv
+import importlib.util
+import io
+import re
+import sys
+from datetime import date, datetime, time, timezone
+from pathlib import Path
+import tempfile
+from types import ModuleType, SimpleNamespace
+import unittest
+from unittest.mock import Mock, patch
+
+
+# The regression tests use real iCalendar parsing, with no CalDAV connection.
+spec = importlib.util.spec_from_file_location(
+    'crealead_caldav', Path(__file__).resolve().parents[1] / 'crealead-caldav.py')
+exporter = importlib.util.module_from_spec(spec)
+with patch.dict('sys.modules', {'caldav': ModuleType('caldav')}):
+    spec.loader.exec_module(exporter)
+
+
+def event_data(properties):
+    return SimpleNamespace(data=(
+        'BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\n'
+        + properties.replace('\n', '\r\n')
+        + '\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n'))
+
+
+class ExportEventsTests(unittest.TestCase):
+    def export(self, *events):
+        server = SimpleNamespace(name='Agenda de test', date_search=Mock(return_value=events))
+        config = dict(year_start=2026, month_start=10, day_start=1,
+                      year_end=2026, month_end=11, day_end=1)
+        errors = io.StringIO()
+        with tempfile.TemporaryDirectory() as directory:
+            with patch.object(exporter, '__file__', str(Path(directory) / 'export.py')), \
+                    contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(errors):
+                with exporter.log_output():
+                    result = exporter.get_all_events(config, [
+                        {'csv_name': 'test.csv', 'calendar_server': server}])
+            self.log = (Path(directory) / 'logs/export.log').read_text(encoding='utf-8')
+        self.assertTrue(server.date_search.call_args.kwargs['expand'])
+        return result[0]['line'], errors.getvalue()
+
+    def test_timezone_parameters_and_chronological_sort(self):
+        rows, errors = self.export(
+            event_data('SUMMARY:Later\nDTSTART;TZID=Europe/Paris:20261015T140000\n'
+                       'DTEND;TZID=Europe/Paris:20261015T150000'),
+            event_data('SUMMARY:Earlier\nDTSTART:20261015T080000Z\n'
+                       'DTEND:20261015T090000Z'))
+        self.assertEqual(errors, '')
+        self.assertEqual([row.title for row in rows], ['Earlier', 'Later'])
+        self.assertEqual([row.start_time for row in rows], [time(10), time(14)])
+        self.assertEqual([row.end_time for row in rows], [time(11), time(15)])
+
+    def test_utc_conversion_in_winter(self):
+        rows, errors = self.export(event_data(
+            'SUMMARY:Winter\nDTSTART:20260115T080000Z\nDTEND:20260115T090000Z'))
+        self.assertEqual(errors, '')
+        self.assertEqual(rows[0].start_time, time(9))
+        self.assertEqual(rows[0].end_time, time(10))
+
+    def test_other_timezone_is_converted_to_paris(self):
+        rows, errors = self.export(event_data(
+            'SUMMARY:Call\nDTSTART;TZID=America/New_York:20261015T090000\n'
+            'DTEND;TZID=America/New_York:20261015T100000'))
+        self.assertEqual(errors, '')
+        self.assertEqual(rows[0].start_time, time(15))
+        self.assertEqual(rows[0].end_time, time(16))
+
+    def test_date_only_values_keep_their_dates_at_midnight(self):
+        rows, errors = self.export(event_data(
+            'SUMMARY:Day\nDTSTART;VALUE=DATE:20261015\nDTEND;VALUE=DATE:20261016'))
+        self.assertEqual(errors, '')
+        self.assertEqual(rows[0].start_date, date(2026, 10, 15))
+        self.assertEqual(rows[0].end_date, date(2026, 10, 16))
+        self.assertEqual(rows[0].start_time, time(0))
+        self.assertEqual(rows[0].end_time, time(0))
+
+    def test_floating_times_are_local(self):
+        rows, errors = self.export(event_data(
+            'SUMMARY:Local\nDTSTART:20261015T090000\nDTEND:20261015T100000'))
+        self.assertEqual(errors, '')
+        self.assertEqual(rows[0].start_time, time(9))
+        self.assertEqual(rows[0].end_time, time(10))
+
+    def test_duration_can_supply_end_time(self):
+        rows, errors = self.export(event_data(
+            'SUMMARY:Duration\nDTSTART:20261015T080000Z\nDURATION:PT1H30M'))
+        self.assertEqual(errors, '')
+        self.assertEqual(rows[0].end_time, time(11, 30))
+
+    def test_missing_or_invalid_dates_are_logged_and_skipped(self):
+        for dates in (
+            'DTEND:20261015T090000Z',
+            'DTSTART:20261015T080000Z',
+            'DTSTART:invalid\nDTEND:20261015T090000Z',
+            'DTSTART:20261015T080000Z\nDTEND:invalid',
+        ):
+            with self.subTest(dates=dates):
+                rows, errors = self.export(
+                    event_data('UID:bad-event\nSUMMARY:Invalid\n' + dates),
+                    event_data('SUMMARY:Valid\nDTSTART:20261015T080000Z\n'
+                               'DTEND:20261015T090000Z'))
+                self.assertEqual([row.title for row in rows], ['Valid'])
+                self.assertIn('bad-event', errors)
+                self.assertIn('test.csv', errors)
+                self.assertIn('événement non exporté', errors)
+                self.assertIn("Calendrier='Agenda de test'", self.log)
+                self.assertIn("titre='Invalid'", self.log)
+                self.assertIn('début=', self.log)
+                self.assertIn('fin=', self.log)
+                self.assertIn('dates de début/fin absentes ou invalides', self.log)
+                self.assertEqual(self.log.count('[warning][event] - '), 1)
+
+    def test_event_without_summary_is_still_skipped(self):
+        rows, errors = self.export(event_data(
+            'DTSTART:20261015T080000Z\nDTEND:20261015T090000Z'))
+        self.assertEqual(rows, [])
+        self.assertIn('propriété SUMMARY absente', errors)
+        self.assertIn("titre='indisponible'", self.log)
+        self.assertIn("début='2026-10-15T08:00:00Z'", self.log)
+        self.assertIn("Calendrier='Agenda de test'", self.log)
+        self.assertEqual(self.log.count('[warning][event] - '), 1)
+
+    def test_malformed_calendar_does_not_block_other_events(self):
+        rows, errors = self.export(
+            SimpleNamespace(data='not an iCalendar document'),
+            event_data('SUMMARY:Valid\nDTSTART:20261015T080000Z\n'
+                       'DTEND:20261015T090000Z'))
+        self.assertEqual([row.title for row in rows], ['Valid'])
+        self.assertIn('document iCalendar illisible', errors)
+        self.assertIn("titre='indisponible'", self.log)
+        self.assertIn("début='indisponible'", self.log)
+
+    def test_malformed_document_recovers_each_event_context(self):
+        rows, errors = self.export(SimpleNamespace(data=(
+            'BEGIN:VEVENT\nUID:first\nSUMMARY;LANGUAGE=fr:Réunion:\n suite\n'
+            'DTSTART;TZID=Europe/Paris:20261015T090000\nEND:VEVENT\n'
+            'BEGIN:VEVENT\nUID:second\nSUMMARY:Autre\n'
+            'DTSTART:20261016T080000Z\nEND:VEVENT\n')))
+        # Multiple root components make Calendar.from_ical reject the document.
+        self.assertEqual(rows, [])
+        self.assertEqual(self.log.count('[warning][event] - '), 2)
+        self.assertIn("titre='Réunion:suite'", self.log)
+        self.assertIn("début='20261015T090000'", self.log)
+        self.assertIn("titre='Autre'", self.log)
+        self.assertIn("UID='second'", self.log)
+        self.assertIn('document iCalendar illisible', errors)
+
+    def test_resource_without_event_is_logged(self):
+        rows, errors = self.export(SimpleNamespace(data=(
+            'BEGIN:VCALENDAR\r\nVERSION:2.0\r\nEND:VCALENDAR\r\n')))
+        self.assertEqual(rows, [])
+        self.assertIn('aucun composant VEVENT', errors)
+        self.assertIn("Calendrier='Agenda de test'", self.log)
+        self.assertEqual(self.log.count('[warning][event] - '), 1)
+
+    def test_invalid_date_keeps_raw_value_in_warning(self):
+        rows, errors = self.export(event_data(
+            'SUMMARY:Invalid\nDTSTART:invalid\nDTEND:20261015T090000Z'))
+        self.assertEqual(rows, [])
+        self.assertIn("début='invalid'", self.log)
+        self.assertIn('dates de début/fin absentes ou invalides', errors)
+
+    def test_text_parameters_folding_colons_and_csv_output(self):
+        rows, errors = self.export(event_data(
+            'SUMMARY;LANGUAGE=fr:Projet: réunion\n'
+            'DTSTART:20261015T080000Z\nDTEND:20261015T090000Z\n'
+            'CATEGORIES:Projet A,Projet B\nLOCATION:Bureau: Montpellier\n'
+            'DESCRIPTION:text/html,%3Cb%3EClient%3C/b%3E:\n suite'))
+        self.assertEqual(errors, '')
+        with tempfile.TemporaryDirectory() as directory:
+            filename = Path(directory) / 'export.csv'
+            exporter.write_csv(filename, rows)
+            with filename.open(newline='') as csv_file:
+                exported = list(csv.reader(csv_file, delimiter=';'))
+        self.assertEqual(len(exported), 2)
+        self.assertEqual(exported[1], [
+            'Projet: réunion', '2026-10-15', '10:00:00', '2026-10-15',
+            '11:00:00', 'Projet A,Projet B', 'Bureau: Montpellier', 'Client:suite'])
+
+
+class LogOutputTests(unittest.TestCase):
+    def messages(self, log):
+        messages = []
+        for line in log.splitlines():
+            match = re.fullmatch(r'\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\]: (.*)', line)
+            self.assertIsNotNone(match, line)
+            messages.append(match.group(1))
+        return messages
+
+    def test_timestamp_uses_utc(self):
+        with patch.object(exporter, 'datetime') as clock:
+            clock.now.return_value = datetime(2026, 10, 15, 12, 34, 56, tzinfo=timezone.utc)
+            self.assertEqual(exporter.utc_timestamp(), '2026-10-15T12:34:56Z')
+            clock.now.assert_called_once_with(timezone.utc)
+
+    def test_fragmented_and_multiline_writes_have_one_prefix_per_line(self):
+        console = io.StringIO()
+        with tempfile.TemporaryDirectory() as directory:
+            with patch.object(exporter, '__file__', str(Path(directory) / 'export.py')), \
+                    contextlib.redirect_stdout(console):
+                with exporter.log_output():
+                    print('CSV', '...', 2)
+                    sys.stdout.write('Début')
+                    sys.stdout.write(' de ligne\n\nAutre ligne\n')
+            messages = self.messages((Path(directory) / 'logs/export.log').read_text(encoding='utf-8'))
+        self.assertEqual(messages, [
+            '[info] - CSV ... 2', '[info] - Début de ligne', '[info] - ', '[info] - Autre ligne'])
+        self.assertEqual(console.getvalue(), 'CSV ... 2\nDébut de ligne\n\nAutre ligne\n')
+
+    def test_event_warning_has_own_level_context_and_escaped_newlines(self):
+        console, errors = io.StringIO(), io.StringIO()
+        component = exporter.Calendar.from_ical(event_data(
+            'UID:event-1\nSUMMARY:Réunion\\nSuite\n'
+            'DTSTART;TZID=Europe/Paris:20261015T100000\n'
+            'DTEND;TZID=Europe/Paris:20261015T110000').data).walk('VEVENT')[0]
+        with tempfile.TemporaryDirectory() as directory:
+            with patch.object(exporter, '__file__', str(Path(directory) / 'export.py')), \
+                    contextlib.redirect_stdout(console), contextlib.redirect_stderr(errors):
+                with exporter.log_output():
+                    sys.stdout.write('En cours')
+                    exporter.log_skipped_event(
+                        {'calendar_name': 'Calendrier configuré', 'csv_name': 'test.csv'},
+                        component, 'motif\nsur deux lignes')
+                    print('Suite')
+            messages = self.messages((Path(directory) / 'logs/export.log').read_text(encoding='utf-8'))
+        self.assertEqual(len(messages), 3)
+        self.assertEqual(messages[0], '[info] - En cours')
+        self.assertTrue(messages[1].startswith('[warning][event] - '))
+        self.assertNotIn('[info]', messages[1])
+        self.assertIn("Calendrier='Calendrier configuré'", messages[1])
+        self.assertIn("titre='Réunion\\nSuite'", messages[1])
+        self.assertIn("début='2026-10-15T08:00:00Z'", messages[1])
+        self.assertIn('motif\\nsur deux lignes', messages[1])
+        self.assertEqual(messages[2], '[info] - Suite')
+        self.assertEqual(console.getvalue(), 'En coursSuite\n')
+        self.assertTrue(errors.getvalue().startswith('[warning][event] - '))
+
+    def test_appended_runs_without_final_newline_remain_separate(self):
+        with tempfile.TemporaryDirectory() as directory:
+            with patch.object(exporter, '__file__', str(Path(directory) / 'export.py')), \
+                    contextlib.redirect_stdout(io.StringIO()):
+                for message in ('Premier', 'Deuxième'):
+                    with exporter.log_output():
+                        sys.stdout.write(message)
+            self.assertEqual(
+                self.messages((Path(directory) / 'logs/export.log').read_text(encoding='utf-8')),
+                ['[info] - Premier', '[info] - Deuxième'])
+
+    def test_system_exit_message_is_saved(self):
+        with tempfile.TemporaryDirectory() as directory:
+            with patch.object(exporter, '__file__', str(Path(directory) / 'export.py')):
+                with self.assertRaises(SystemExit):
+                    with exporter.log_output():
+                        sys.exit('Configuration invalide')
+            self.assertEqual(
+                self.messages((Path(directory) / 'logs/export.log').read_text(encoding='utf-8')),
+                ['[info] - Configuration invalide'])
+
+    def test_creates_logs_next_to_script_and_copies_both_streams(self):
+        stdout, stderr = io.StringIO(), io.StringIO()
+        with tempfile.TemporaryDirectory() as directory:
+            script_path = Path(directory) / 'crealead-caldav.py'
+            with patch.object(exporter, '__file__', str(script_path)), \
+                    contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+                with exporter.log_output():
+                    print('Export démarré')
+                    print('Événement ignoré', file=sys.stderr)
+                    sys.stdout.write('Terminé')
+                    sys.stdout.flush()
+                    self.assertEqual(
+                        self.messages((Path(directory) / 'logs/crealead-caldav.log').read_text(encoding='utf-8')),
+                        ['[info] - Export démarré', '[info] - Événement ignoré', '[info] - Terminé'])
+                self.assertIs(sys.stdout, stdout)
+                self.assertIs(sys.stderr, stderr)
+        self.assertEqual(stdout.getvalue(), 'Export démarré\nTerminé')
+        self.assertEqual(stderr.getvalue(), 'Événement ignoré\n')
+
+    def test_appends_on_next_execution_and_uses_script_name(self):
+        with tempfile.TemporaryDirectory() as directory:
+            with patch.object(exporter, '__file__', str(Path(directory) / 'export.py')), \
+                    contextlib.redirect_stdout(io.StringIO()):
+                for message in ('Premier export', 'Deuxième export'):
+                    with exporter.log_output():
+                        print(message)
+            self.assertEqual(
+                self.messages((Path(directory) / 'logs/export.log').read_text(encoding='utf-8')),
+                ['[info] - Premier export', '[info] - Deuxième export'])
+
+    def test_exception_traceback_is_saved_and_streams_are_restored(self):
+        stdout, stderr = io.StringIO(), io.StringIO()
+        with tempfile.TemporaryDirectory() as directory:
+            with patch.object(exporter, '__file__', str(Path(directory) / 'export.py')), \
+                    contextlib.redirect_stdout(stdout), contextlib.redirect_stderr(stderr):
+                with self.assertRaisesRegex(ValueError, 'date invalide'):
+                    with exporter.log_output():
+                        print('Avant erreur')
+                        raise ValueError('date invalide')
+                self.assertIs(sys.stdout, stdout)
+                self.assertIs(sys.stderr, stderr)
+            log = (Path(directory) / 'logs/export.log').read_text(encoding='utf-8')
+        messages = self.messages(log)
+        self.assertEqual(messages[0], '[info] - Avant erreur')
+        self.assertTrue(messages[1].startswith('[info] - Traceback'))
+        self.assertTrue(all(message.startswith('[info] - ') for message in messages))
+        self.assertIn('ValueError: date invalide', log)
+        self.assertEqual(stdout.getvalue(), 'Avant erreur\n')
+        self.assertEqual(stderr.getvalue(), '')
+
+    def test_system_exit_keeps_exit_code_without_logging_traceback(self):
+        with tempfile.TemporaryDirectory() as directory:
+            with patch.object(exporter, '__file__', str(Path(directory) / 'export.py')), \
+                    contextlib.redirect_stderr(io.StringIO()):
+                with self.assertRaises(SystemExit) as caught:
+                    with exporter.log_output():
+                        print('Connexion impossible', file=sys.stderr)
+                        sys.exit(2)
+            self.assertEqual(caught.exception.code, 2)
+            self.assertEqual(
+                self.messages((Path(directory) / 'logs/export.log').read_text(encoding='utf-8')),
+                ['[info] - Connexion impossible'])
+
+
+class ExportFailureTests(unittest.TestCase):
+    def test_csv_failure_logs_events_in_current_and_pending_calendars(self):
+        config = dict(year_start=2026, month_start=10, day_start=1,
+                      year_end=2026, month_end=11, day_end=1)
+        with tempfile.TemporaryDirectory() as directory:
+            paths = [Path(directory) / 'first.csv',
+                     Path(directory) / 'missing/failed.csv',
+                     Path(directory) / 'pending.csv']
+            calendars = [
+                {'csv_name': str(path), 'calendar_server': SimpleNamespace(
+                    name='Agenda {}'.format(index), date_search=Mock(return_value=[event_data(
+                        'SUMMARY:Event {}\nUID:uid-{}\nDTSTART:20261015T080000Z\n'
+                        'DTEND:20261015T090000Z'.format(index, index))]))}
+                for index, path in enumerate(paths)
+            ]
+            with patch.object(exporter, '__file__', str(Path(directory) / 'export.py')), \
+                    patch.object(exporter, 'load_json_config', return_value=config), \
+                    patch.object(exporter, 'init_connection', return_value=[]), \
+                    patch.object(exporter, 'link_calendars', return_value=calendars), \
+                    contextlib.redirect_stdout(io.StringIO()), \
+                    contextlib.redirect_stderr(io.StringIO()):
+                with self.assertRaises(OSError):
+                    with exporter.log_output():
+                        exporter.main()
+            log = (Path(directory) / 'logs/export.log').read_text(encoding='utf-8')
+            self.assertTrue(paths[0].is_file())
+            self.assertFalse(paths[2].exists())
+        warnings = [line for line in log.splitlines() if '[warning][event]' in line]
+        self.assertEqual(len(warnings), 2)
+        for index, warning in enumerate(warnings, start=1):
+            self.assertIn("Calendrier='Agenda {}'".format(index), warning)
+            self.assertIn("titre='Event {}'".format(index), warning)
+            self.assertIn("début='2026-10-15T08:00:00Z'", warning)
+            self.assertIn('export CSV interrompu', warning)
+
+
+if __name__ == '__main__':
+    unittest.main()