android-test: sample 3/6/9/12-month wallet tags as WARN only

Pick nearest release tags to 90/180/270/365 days for the older matrix
slot; failures there never hard-block (only ≤14d releases can).

scripts/taler-monitoring/android-test/GUI-AUTOMATION-NOTES.md

@@ -245,14 +245,15 @@ Scripts **today** implement Android only; they should honour:
 
 | Variant | Source | Severity | Purpose |
 |---------|--------|----------|---------|
-| **stable-self** | tag `wallet-1.6.1` rebuilt | WARN | Our rebuild of stable — never hard-blocks |
+| **stable-self** | stable tag rebuilt | WARN | Our rebuild — never hard-blocks |
 | **published** | F-Droid current APK | **≤14d → BLOCKER**, else WARN | What users install |
-| **older-pub / older-self** | previous `wallet-*` tags | **≤14d → BLOCKER**, else WARN | Regression on recent releases only |
+| **older / milestones** | tags ~**3 / 6 / 9 / 12 mo** | **always WARN** | Long-horizon regression, if tags exist |
 | **master** | `origin/master` | WARN | Tip — never hard-blocks |
 | **fix** (optional) | inference branch | soft | GOA automation fixes |
 
-**Two-week window:** `BLOCKER_MAX_AGE_DAYS=14` (git tag age). Older apps are still tried; only young releases hard-block.  
+**Blocker window:** only releases ≤ 14 days.  
-Default matrix: `stable-self,published,older,master`. See README.
+**Milestones:** nearest tags to 90/180/270/365 days (±50d) — warn only.  
+Default matrix: `stable-self,published,older,master`.
 
 ---
 

scripts/taler-monitoring/android-test/README.md

@@ -38,22 +38,21 @@ Runs several smokes so a single odd developer build cannot be the only sample:
 |---------|------|
 | Order | Variant | Severity | What |
 |------|---------|----------|------|
-| **1** | **stable-self** | WARN | Rebuild tag `wallet-1.6.1` on this host |
+| **1** | **stable-self** | WARN | Rebuild current stable tag |
-| **2** | **published** | **age rule** | Current F-Droid APK |
+| **2** | **published** | age ≤14d → **BLOCKER**, else WARN | Current F-Droid APK |
-| **3** | **older-*** | **age rule** | Previous `wallet-*` tags (APK if on F-Droid, else self-build) |
+| **3** | **older / milestones** | **always WARN** | Tags nearest **3 / 6 / 9 / 12 months** (if available) |
 | **4** | **master** | WARN | Rebuild `origin/master` |
 
-**Age rule (released apps):** if git-tag age **≤ 14 days** (`BLOCKER_MAX_AGE_DAYS`) → fail is **BLOCKER** + `FAIL_FAST`.  
+**Milestones:** `MILESTONE_DAYS="90 180 270 365"` (± `MILESTONE_TOLERANCE_DAYS=50`).  
-Older releases are still smoked, but fail only as **WARN**.  
+Failures there are warnings only — never hard blockers.  
-Self-build of tip/stable-self is never a hard blocker.
+**Young releases only** (≤ 14 days): hard blocker on fail.
 
 ```bash
 ./run-android-variant-matrix.sh
 STACK=goa ./run-android-variant-matrix.sh
-# without older history:
 INCLUDE_OLDER=0 VARIANTS=stable-self,published,master ./run-android-variant-matrix.sh
-# force current published always blocker:
+# custom milestones (days):
-PUBLISHED_FORCE_BLOCKER=1 ./run-android-variant-matrix.sh
+MILESTONE_DAYS="90 180 270 365" ./run-android-variant-matrix.sh
 ```
 
 Artifacts + `SUMMARY.txt` under `out-matrix-<timestamp>/`.

scripts/taler-monitoring/android-test/lib_release_age.sh

@@ -46,15 +46,57 @@ severity_for_tag() {
 }
 
 # List wallet-* release tags newest first (exclude rc/dev).
-# Args: max count (default 5)
+# Args: max count (default 5). Pass 0 or "all" for no limit.
 list_wallet_release_tags() {
   local n="${1:-5}"
   local src="${TALER_ANDROID_SRC:-$HOME/taler/taler-android}"
   [ -d "$src/.git" ] || return 1
   git -C "$src" fetch --tags origin 2>/dev/null || true
-  git -C "$src" for-each-ref --sort=-creatordate --format='%(refname:short)' refs/tags \
+  local cmd=(git -C "$src" for-each-ref --sort=-creatordate --format='%(refname:short)' refs/tags)
-    | grep -E '^wallet-[0-9]+\.[0-9]+(\.[0-9]+)?$' \
+  if [ "$n" = "all" ] || [ "$n" = "0" ]; then
-    | head -n "$n"
+    "${cmd[@]}" | grep -E '^wallet-[0-9]+\.[0-9]+(\.[0-9]+)?$'
+  else
+    "${cmd[@]}" | grep -E '^wallet-[0-9]+\.[0-9]+(\.[0-9]+)?$' | head -n "$n"
+  fi
+}
+
+# Pick one tag closest to each age milestone (days). Always intended as WARN samples.
+# Default milestones: 3,6,9,12 months ≈ 90,180,270,365 days.
+# Env: MILESTONE_DAYS="90 180 270 365"  MILESTONE_TOLERANCE_DAYS=50
+# Prints lines: TAG AGE_DAYS TARGET_DAYS  (only when a tag within tolerance exists)
+select_milestone_tags() {
+  local src="${TALER_ANDROID_SRC:-$HOME/taler/taler-android}"
+  local milestones="${MILESTONE_DAYS:-90 180 270 365}"
+  local tol="${MILESTONE_TOLERANCE_DAYS:-50}"
+  local skip="${1:-}"   # optional tag to exclude (e.g. current STABLE_TAG)
+  local -a tags=()
+  mapfile -t tags < <(list_wallet_release_tags all 2>/dev/null || true)
+  [ "${#tags[@]}" -gt 0 ] || return 0
+
+  local target best_tag best_age best_delta age t delta
+  local -A used=()
+  for target in $milestones; do
+    best_tag=""
+    best_age=""
+    best_delta=99999
+    for t in "${tags[@]}"; do
+      [ -n "$t" ] || continue
+      [ "$t" = "$skip" ] && continue
+      [ -n "${used[$t]:-}" ] && continue
+      age=$(release_age_days "$t" "$src" 2>/dev/null || true)
+      [[ "$age" =~ ^[0-9]+$ ]] || continue
+      delta=$(( age > target ? age - target : target - age ))
+      if [ "$delta" -le "$tol" ] && [ "$delta" -lt "$best_delta" ]; then
+        best_delta=$delta
+        best_tag=$t
+        best_age=$age
+      fi
+    done
+    if [ -n "$best_tag" ]; then
+      used[$best_tag]=1
+      echo "$best_tag $best_age $target"
+    fi
+  done
 }
 
 # Guess F-Droid APK URL for a wallet version name (e.g. 1.6.1).

scripts/taler-monitoring/android-test/run-android-variant-matrix.sh

@@ -4,22 +4,23 @@
 # Default order:
 #   1) stable-self     — rebuild STABLE_TAG (always WARN on fail)
 #   2) published       — current F-Droid suggested APK
-#   3) older-*         — previous release tags (APK and/or self-build) if available
+#   3) older / milestones — releases near **3 / 6 / 9 / 12 months** (WARN only)
-#   4) master          — tip (always WARN on fail)
+#   4) master             — tip (always WARN on fail)
 #
 # Severity (released apps):
 #   Age ≤ BLOCKER_MAX_AGE_DAYS (default **14**) → **BLOCKER** on fail (FAIL_FAST)
-#   Age  > 14 days (or unknown)                → **WARN** only
+#   Age  > 14 days, incl. 3/6/9/12‑month samples → **WARN** only
-#   master / pure self-builds without release age → WARN
+#   master / stable-self                         → WARN
 #
 # Env:
 #   STABLE_TAG, STABLE_APK_URL, STABLE_APK_NAME
 #   MASTER_BRANCH, FIX_BRANCH
 #   VARIANTS          default: stable-self,published,older,master
-#   INCLUDE_OLDER=1   expand token "older" (default 1)
+#   INCLUDE_OLDER=1   expand token "older" / "milestones" (default 1)
-#   OLDER_TAG_COUNT   how many recent wallet-* tags to consider (default 4)
+#   MILESTONE_DAYS    default "90 180 270 365" (≈ 3,6,9,12 months)
+#   MILESTONE_TOLERANCE_DAYS  default 50 — max distance to accept a tag
 #   BLOCKER_MAX_AGE_DAYS  default 14
-#   PUBLISHED_FORCE_BLOCKER=1  always treat current published as blocker (default 0 = age rule)
+#   PUBLISHED_FORCE_BLOCKER=1  always treat current published as blocker
 #   FAIL_FAST=1, GUI=0, STACK=…
 #
 set -euo pipefail
@@ -36,14 +37,15 @@ ROOT=$(cd "$(dirname "$0")" && pwd)
 : "${FIX_BRANCH:=dev/hernani-inference/fix-bank-withdraw-auto-exchange}"
 : "${VARIANTS:=stable-self,published,older,master}"
 : "${INCLUDE_OLDER:=1}"
-: "${OLDER_TAG_COUNT:=4}"
+: "${MILESTONE_DAYS:=90 180 270 365}"
+: "${MILESTONE_TOLERANCE_DAYS:=50}"
 : "${BLOCKER_MAX_AGE_DAYS:=14}"
 : "${PUBLISHED_FORCE_BLOCKER:=0}"
 : "${FAIL_FAST:=1}"
 : "${GUI:=0}"
 : "${STACK:=auto}"
 : "${TALER_ANDROID_SRC:=$HOME/taler/taler-android}"
-export TALER_ANDROID_SRC BLOCKER_MAX_AGE_DAYS
+export TALER_ANDROID_SRC BLOCKER_MAX_AGE_DAYS MILESTONE_DAYS MILESTONE_TOLERANCE_DAYS
 
 TS=$(date +%Y%m%d-%H%M%S)
 MATRIX_OUT="${MATRIX_OUT:-$ROOT/out-matrix-$TS}"
@@ -53,7 +55,8 @@ SUMMARY="$MATRIX_OUT/SUMMARY.txt"
 
 echo "=== Android variant matrix ===" | tee -a "$SUMMARY"
 echo "STACK=$STACK  GUI=$GUI  headless=${EMULATOR_HEADLESS}  variants=$VARIANTS" | tee -a "$SUMMARY"
-echo "STABLE_TAG=$STABLE_TAG  BLOCKER_MAX_AGE_DAYS=$BLOCKER_MAX_AGE_DAYS  OLDER_TAG_COUNT=$OLDER_TAG_COUNT" | tee -a "$SUMMARY"
+echo "STABLE_TAG=$STABLE_TAG  BLOCKER_MAX_AGE_DAYS=$BLOCKER_MAX_AGE_DAYS" | tee -a "$SUMMARY"
+echo "milestones(days)=$MILESTONE_DAYS  tolerance=$MILESTONE_TOLERANCE_DAYS (always WARN)" | tee -a "$SUMMARY"
 echo "out: $MATRIX_OUT" | tee -a "$SUMMARY"
 
 android_ensure_device || {
@@ -64,45 +67,51 @@ export SERIAL ANDROID_SERIAL
 echo "device: $SERIAL" | tee -a "$SUMMARY"
 
 # --- expand VARIANTS (token "older" → concrete older-pub / older-self entries) ---
+# Append one older release as WARN-only (pub APK if possible, else self-build).
+append_older_warn() {
+  local t="$1" age="$2" target="${3:-}"
+  local vn meta apk_vc apk_url
+  vn="${t#wallet-}"
+  if [ -n "$target" ]; then
+    echo "  milestone ~${target}d → $t (age=${age}d) severity=WARN" | tee -a "$SUMMARY"
+  else
+    echo "  older $t (age=${age}d) severity=WARN" | tee -a "$SUMMARY"
+  fi
+  meta=$(fdroid_apk_for_version_name "$vn" 2>/dev/null || true)
+  if [ -n "$meta" ]; then
+    apk_vc="${meta%%|*}"
+    apk_url="${meta#*|}"
+    if fdroid_apk_exists "$apk_url"; then
+      out+=("older-pub:${vn}:${apk_vc}:warn")
+      return
+    fi
+    echo "  (no F-Droid APK for $vn — self-build only)" | tee -a "$SUMMARY"
+  fi
+  out+=("older-self:${t}:warn")
+}
+
 expand_variants() {
   local raw="$1"
   local -a out=()
-  local v tag vn age sev stable_vn
+  local v tag vn age sev line t target
-  stable_vn="${STABLE_TAG#wallet-}"
 
   IFS=',' read -r -a toks <<<"$raw"
   for v in "${toks[@]}"; do
     v=$(echo "$v" | tr -d '[:space:]')
     [ -n "$v" ] || continue
-    if [ "$v" = "older" ] || [ "$v" = "older-releases" ]; then
+    if [ "$v" = "older" ] || [ "$v" = "older-releases" ] || [ "$v" = "milestones" ]; then
       [ "$INCLUDE_OLDER" = "1" ] || continue
-      local -a tags=()
+      # Prefer 3/6/9/12-month samples (always WARN). Fall back: nothing if no tags nearby.
-      mapfile -t tags < <(list_wallet_release_tags "$OLDER_TAG_COUNT" 2>/dev/null || true)
+      local found=0
-      local t
+      while read -r t age target; do
-      for t in "${tags[@]}"; do
         [ -n "$t" ] || continue
-        # skip current stable tag (already covered by published / stable-self)
         [ "$t" = "$STABLE_TAG" ] && continue
-        vn="${t#wallet-}"
+        append_older_warn "$t" "$age" "$target"
-        age=$(release_age_days "$t" 2>/dev/null || echo "")
+        found=1
-        sev=$(severity_from_age_days "$age")
+      done < <(select_milestone_tags "$STABLE_TAG" 2>/dev/null || true)
-        echo "  older candidate $t age_days=${age:-?} severity=$sev" | tee -a "$SUMMARY"
+      if [ "$found" = "0" ]; then
-        # Prefer published APK when downloadable; always also allow self-build token
+        echo "  (no milestone tags within ±${MILESTONE_TOLERANCE_DAYS}d of $MILESTONE_DAYS)" | tee -a "$SUMMARY"
-        local meta apk_vc apk_url
+      fi
-        meta=$(fdroid_apk_for_version_name "$vn" 2>/dev/null || true)
-        if [ -n "$meta" ]; then
-          apk_vc="${meta%%|*}"
-          apk_url="${meta#*|}"
-          if fdroid_apk_exists "$apk_url"; then
-            out+=("older-pub:${vn}:${apk_vc}:${sev}")
-          else
-            echo "  (no F-Droid APK for $vn at $apk_url — self-build only)" | tee -a "$SUMMARY"
-            out+=("older-self:${t}:${sev}")
-          fi
-        else
-          out+=("older-self:${t}:${sev}")
-        fi
-      done
     else
       out+=("$v")
     fi
@@ -296,7 +305,7 @@ done
 
 echo "" | tee -a "$SUMMARY"
 echo "=== matrix done (overall=$overall) ===" | tee -a "$SUMMARY"
-echo "rule: released app age ≤ ${BLOCKER_MAX_AGE_DAYS}d → BLOCKER on fail; older → WARN" | tee -a "$SUMMARY"
+echo "rule: age ≤ ${BLOCKER_MAX_AGE_DAYS}d → BLOCKER; 3/6/9/12mo milestones + older → WARN only" | tee -a "$SUMMARY"
 for r in "${RESULTS[@]}"; do
   echo "  $r" | tee -a "$SUMMARY"
 done