Repository Public
1package maintenance23import (4 "bytes"5 "errors"6 "fmt"7 "regexp"8 "strings"9 "testing"10 "time"11 "unicode/utf8"1213 "github.com/google/uuid"14)1516// ---------------------------------------------------------------------------17// Strict line-level iCalendar parser (test only).18// ---------------------------------------------------------------------------1920type icsProp struct {21 name string22 params map[string]string23 value string24}2526type icsComp struct {27 name string28 props []icsProp29 children []*icsComp30}3132func (c *icsComp) get(name string) (icsProp, bool) {33 for _, p := range c.props {34 if p.name == name {35 return p, true36 }37 }38 return icsProp{}, false39}4041func (c *icsComp) val(name string) string {42 p, _ := c.get(name)43 return p.value44}4546func (c *icsComp) kids(name string) []*icsComp {47 var out []*icsComp48 for _, k := range c.children {49 if k.name == name {50 out = append(out, k)51 }52 }53 return out54}5556var (57 reName = regexp.MustCompile(`^[A-Z0-9-]+$`)58 reUTC = regexp.MustCompile(`^\d{8}T\d{6}Z$`)59 reLocal = regexp.MustCompile(`^\d{8}T\d{6}$`)60 reOffset = regexp.MustCompile(`^[+-]\d{4}(\d{2})?$`)61)6263func checkUTC(v string) error {64 if !reUTC.MatchString(v) {65 return fmt.Errorf("bad UTC date-time %q", v)66 }67 _, err := time.Parse("20060102T150405Z", v)68 return err69}7071func checkLocal(v string) error {72 if !reLocal.MatchString(v) {73 return fmt.Errorf("bad local date-time %q", v)74 }75 _, err := time.Parse("20060102T150405", v)76 return err77}7879// checkText rejects unescaped ',' ';' and invalid escapes in a TEXT value.80func checkText(v string) error {81 for i := 0; i < len(v); i++ {82 switch v[i] {83 case '\\':84 if i+1 >= len(v) || !strings.ContainsRune(`\;,nN`, rune(v[i+1])) {85 return fmt.Errorf("bad escape in TEXT %q", v)86 }87 i++88 case ',', ';':89 return fmt.Errorf("unescaped %q in TEXT %q", v[i], v)90 case '\n', '\r':91 return fmt.Errorf("raw newline in TEXT %q", v)92 }93 }94 return nil95}9697func unescapeText(v string) string {98 var sb strings.Builder99 for i := 0; i < len(v); i++ {100 if v[i] == '\\' && i+1 < len(v) {101 i++102 if v[i] == 'n' || v[i] == 'N' {103 sb.WriteByte('\n')104 } else {105 sb.WriteByte(v[i])106 }107 continue108 }109 sb.WriteByte(v[i])110 }111 return sb.String()112}113114// parseICS parses and strictly validates a calendar.115func parseICS(data []byte) (*icsComp, error) {116 if len(data) == 0 {117 return nil, errors.New("empty")118 }119 // 1. CRLF only.120 for i, c := range data {121 if c == '\n' && (i == 0 || data[i-1] != '\r') {122 return nil, fmt.Errorf("bare LF at offset %d", i)123 }124 if c == '\r' && (i+1 >= len(data) || data[i+1] != '\n') {125 return nil, fmt.Errorf("bare CR at offset %d", i)126 }127 }128 if !bytes.HasSuffix(data, []byte("\r\n")) {129 return nil, errors.New("missing final CRLF")130 }131 phys := strings.Split(string(data[:len(data)-2]), "\r\n")132 // 2. Physical line length, unfolding.133 var logical []string134 for i, l := range phys {135 if len(l) > 75 {136 return nil, fmt.Errorf("physical line %d is %d octets", i+1, len(l))137 }138 if l == "" {139 return nil, fmt.Errorf("empty line %d", i+1)140 }141 if l[0] == ' ' || l[0] == '\t' {142 if len(logical) == 0 {143 return nil, errors.New("continuation without a first line")144 }145 logical[len(logical)-1] += l[1:]146 continue147 }148 // The previous logical line is complete here, but a fold must never149 // split a UTF-8 sequence: every physical piece must be valid too.150 logical = append(logical, l)151 }152 for i, l := range phys {153 piece := l154 if piece[0] == ' ' || piece[0] == '\t' {155 piece = piece[1:]156 }157 if !utf8.ValidString(piece) {158 return nil, fmt.Errorf("physical line %d splits a UTF-8 sequence", i+1)159 }160 }161 // 3. Content lines → component tree.162 var root *icsComp163 var stack []*icsComp164 for i, l := range logical {165 if !utf8.ValidString(l) {166 return nil, fmt.Errorf("logical line %d is not valid UTF-8", i+1)167 }168 p, err := parseLine(l)169 if err != nil {170 return nil, fmt.Errorf("line %d: %w", i+1, err)171 }172 switch p.name {173 case "BEGIN":174 c := &icsComp{name: p.value}175 if len(stack) == 0 {176 if root != nil {177 return nil, errors.New("several top-level components")178 }179 root = c180 } else {181 top := stack[len(stack)-1]182 top.children = append(top.children, c)183 }184 stack = append(stack, c)185 case "END":186 if len(stack) == 0 || stack[len(stack)-1].name != p.value {187 return nil, fmt.Errorf("line %d: misnested END:%s", i+1, p.value)188 }189 stack = stack[:len(stack)-1]190 default:191 if len(stack) == 0 {192 return nil, fmt.Errorf("line %d: property outside a component", i+1)193 }194 top := stack[len(stack)-1]195 top.props = append(top.props, p)196 }197 }198 if len(stack) != 0 {199 return nil, fmt.Errorf("unbalanced: %s not closed", stack[len(stack)-1].name)200 }201 if root == nil || root.name != "VCALENDAR" {202 return nil, errors.New("no VCALENDAR")203 }204 return root, checkCalendar(root)205}206207func parseLine(l string) (icsProp, error) {208 colon, inQuote := -1, false209 for i := 0; i < len(l); i++ {210 if l[i] == '"' {211 inQuote = !inQuote212 }213 if l[i] == ':' && !inQuote {214 colon = i215 break216 }217 }218 if colon <= 0 {219 return icsProp{}, fmt.Errorf("no name:value in %q", l)220 }221 parts := strings.Split(l[:colon], ";")222 p := icsProp{name: parts[0], params: map[string]string{}, value: l[colon+1:]}223 if !reName.MatchString(p.name) {224 return p, fmt.Errorf("bad property name %q", p.name)225 }226 for _, kv := range parts[1:] {227 k, v, ok := strings.Cut(kv, "=")228 if !ok || !reName.MatchString(k) || v == "" {229 return p, fmt.Errorf("bad parameter %q", kv)230 }231 p.params[k] = v232 }233 return p, nil234}235236func checkCalendar(cal *icsComp) error {237 for _, req := range []string{"VERSION", "PRODID"} {238 if _, ok := cal.get(req); !ok {239 return fmt.Errorf("VCALENDAR lacks %s", req)240 }241 }242 if cal.val("VERSION") != "2.0" {243 return errors.New("VERSION is not 2.0")244 }245 zones := map[string]bool{}246 for _, c := range cal.children {247 switch c.name {248 case "VTIMEZONE":249 id := c.val("TZID")250 if id == "" {251 return errors.New("VTIMEZONE lacks TZID")252 }253 if zones[id] {254 return fmt.Errorf("duplicate VTIMEZONE %s", id)255 }256 zones[id] = true257 if len(c.children) == 0 {258 return fmt.Errorf("VTIMEZONE %s has no observance", id)259 }260 for _, o := range c.children {261 if o.name != "STANDARD" && o.name != "DAYLIGHT" {262 return fmt.Errorf("unexpected %s in VTIMEZONE", o.name)263 }264 if len(o.children) != 0 {265 return errors.New("nested component in observance")266 }267 if err := checkLocal(o.val("DTSTART")); err != nil {268 return fmt.Errorf("observance DTSTART: %w", err)269 }270 for _, k := range []string{"TZOFFSETFROM", "TZOFFSETTO"} {271 if !reOffset.MatchString(o.val(k)) {272 return fmt.Errorf("bad %s %q", k, o.val(k))273 }274 }275 }276 case "VEVENT":277 default:278 return fmt.Errorf("unexpected component %s", c.name)279 }280 }281 uids := map[string]bool{}282 for _, e := range cal.kids("VEVENT") {283 if len(e.children) != 0 {284 return errors.New("nested component in VEVENT")285 }286 for _, req := range []string{"UID", "DTSTAMP", "DTSTART"} {287 if e.val(req) == "" {288 return fmt.Errorf("VEVENT lacks %s", req)289 }290 }291 count := map[string]int{}292 for _, p := range e.props {293 count[p.name]++294 }295 for _, once := range []string{"UID", "DTSTAMP", "DTSTART", "DTEND", "SUMMARY", "DESCRIPTION", "RRULE", "STATUS", "LAST-MODIFIED"} {296 if count[once] > 1 {297 return fmt.Errorf("VEVENT has %d %s", count[once], once)298 }299 }300 uid := e.val("UID")301 if uids[uid] {302 return fmt.Errorf("duplicate UID %s", uid)303 }304 uids[uid] = true305 for _, p := range e.props {306 switch p.name {307 case "DTSTAMP", "LAST-MODIFIED":308 if err := checkUTC(p.value); err != nil {309 return fmt.Errorf("%s: %w", p.name, err)310 }311 case "DTSTART", "DTEND":312 if tz, ok := p.params["TZID"]; ok {313 if !zones[tz] {314 return fmt.Errorf("TZID %s has no VTIMEZONE", tz)315 }316 if err := checkLocal(p.value); err != nil {317 return fmt.Errorf("%s: %w", p.name, err)318 }319 } else if err := checkUTC(p.value); err != nil {320 return fmt.Errorf("%s: %w", p.name, err)321 }322 case "SUMMARY", "DESCRIPTION":323 if err := checkText(p.value); err != nil {324 return fmt.Errorf("%s: %w", p.name, err)325 }326 case "RRULE":327 seenFreq := false328 for _, part := range strings.Split(p.value, ";") {329 k, v, ok := strings.Cut(part, "=")330 if !ok || v == "" {331 return fmt.Errorf("bad RRULE part %q", part)332 }333 switch k {334 case "FREQ":335 seenFreq = true336 if v != "DAILY" && v != "WEEKLY" && v != "MONTHLY" {337 return fmt.Errorf("bad FREQ %q", v)338 }339 case "UNTIL":340 if err := checkUTC(v); err != nil {341 return fmt.Errorf("UNTIL: %w", err)342 }343 case "BYMONTHDAY", "BYSETPOS":344 default:345 return fmt.Errorf("unexpected RRULE part %q", k)346 }347 }348 if !seenFreq {349 return errors.New("RRULE lacks FREQ")350 }351 if _, ok := e.props[indexOf(e, "DTSTART")].params["TZID"]; !ok {352 return errors.New("RRULE on an event without TZID")353 }354 }355 }356 }357 return nil358}359360func indexOf(c *icsComp, name string) int {361 for i, p := range c.props {362 if p.name == name {363 return i364 }365 }366 return 0367}368369// ---------------------------------------------------------------------------370// The parser itself must be strict.371// ---------------------------------------------------------------------------372373func TestStrictParserRejects(t *testing.T) {374 crlf := func(lines ...string) string { return strings.Join(lines, "\r\n") + "\r\n" }375 head := []string{"BEGIN:VCALENDAR", "VERSION:2.0", "PRODID:x"}376 ev := func(extra ...string) []string {377 l := []string{"BEGIN:VEVENT", "UID:a@b", "DTSTAMP:20260101T000000Z", "DTSTART:20260101T000000Z"}378 l = append(l, extra...)379 return append(l, "END:VEVENT")380 }381 cal := func(body ...[]string) string {382 l := append([]string{}, head...)383 for _, b := range body {384 l = append(l, b...)385 }386 return crlf(append(l, "END:VCALENDAR")...)387 }388 valid := cal(ev("SUMMARY:ok\\, fine"))389 if _, err := parseICS([]byte(valid)); err != nil {390 t.Fatalf("valid calendar rejected: %v", err)391 }392 long := "SUMMARY:" + strings.Repeat("x", 80)393 bad := map[string]string{394 "bare LF": strings.Replace(valid, "\r\nUID", "\nUID", 1),395 "bare CR": strings.Replace(valid, "\r\nUID", "\rUID", 1),396 "no final CRLF": strings.TrimSuffix(valid, "\r\n"),397 "long line": cal(ev(long)),398 "split UTF-8": cal(ev("SUMMARY:caf\xc3", " \xa9")),399 "invalid UTF-8": cal(ev("SUMMARY:caf\xff")),400 "missing UID": cal([]string{"BEGIN:VEVENT", "DTSTAMP:20260101T000000Z", "DTSTART:20260101T000000Z", "END:VEVENT"}),401 "missing DTSTAMP": cal([]string{"BEGIN:VEVENT", "UID:a@b", "DTSTART:20260101T000000Z", "END:VEVENT"}),402 "missing DTSTART": cal([]string{"BEGIN:VEVENT", "UID:a@b", "DTSTAMP:20260101T000000Z", "END:VEVENT"}),403 "unbalanced": crlf(append(append([]string{}, head...), "BEGIN:VEVENT", "UID:a@b", "DTSTAMP:20260101T000000Z", "DTSTART:20260101T000000Z")...),404 "misnested": crlf(append(append([]string{}, head...), "BEGIN:VEVENT", "UID:a@b", "DTSTAMP:20260101T000000Z", "DTSTART:20260101T000000Z", "END:VCALENDAR", "END:VEVENT")...),405 "END without BEGIN": crlf("END:VCALENDAR"),406 "TZID without VTZ": cal([]string{"BEGIN:VEVENT", "UID:a@b", "DTSTAMP:20260101T000000Z", "DTSTART;TZID=America/Toronto:20260101T000000", "END:VEVENT"}),407 "bad date": cal([]string{"BEGIN:VEVENT", "UID:a@b", "DTSTAMP:20260101T000000Z", "DTSTART:2026-01-01T00:00:00Z", "END:VEVENT"}),408 "impossible date": cal([]string{"BEGIN:VEVENT", "UID:a@b", "DTSTAMP:20260101T000000Z", "DTSTART:20261341T000000Z", "END:VEVENT"}),409 "local without TZID": cal([]string{"BEGIN:VEVENT", "UID:a@b", "DTSTAMP:20260101T000000Z", "DTSTART:20260101T000000", "END:VEVENT"}),410 "unescaped comma": cal(ev("SUMMARY:a, b")),411 "unescaped semicolon": cal(ev("DESCRIPTION:a; b")),412 "bad escape": cal(ev("SUMMARY:a\\x")),413 "trailing backslash": cal(ev("SUMMARY:a\\")),414 "duplicate UID": cal(ev(), ev()),415 "bad UNTIL": cal(ev("RRULE:FREQ=DAILY;UNTIL=20260101")),416 "property outside": crlf("VERSION:2.0", "BEGIN:VCALENDAR", "VERSION:2.0", "PRODID:x", "END:VCALENDAR"),417 "continuation at start": crlf(" BEGIN:VCALENDAR", "VERSION:2.0", "PRODID:x", "END:VCALENDAR"),418 }419 for name, data := range bad {420 if _, err := parseICS([]byte(data)); err == nil {421 t.Errorf("%s: accepted", name)422 }423 }424}425426// ---------------------------------------------------------------------------427// WriteICS428// ---------------------------------------------------------------------------429430func icsWin(n byte, title, zone, rec, start, end string) Window {431 w := win(zone, rec, start, end)432 w.ID = uuid.MustParse(fmt.Sprintf("00000000-0000-4000-8000-0000000000%02x", n))433 w.Title = title434 w.UpdatedAt = z("2026-02-03T04:05:06Z")435 return w436}437438const (439 longTitle = "Mise à jour générale du système — nœuds M3U96a/M3U96b 🔧🚀 " +440 "éééééééééééééééééééééééééééééééééééééééé 日本語のテキスト 🛠️ fin"441 trickyDesc = "Étapes: a, b; c\\d\nLigne 2 avec \"guillemets\", virgules,, et ;;\n\nFin \\n littéral 🔧"442)443444func sampleWindows() []Window {445 const tor, par = "America/Toronto", "Europe/Paris"446 long := icsWin(1, longTitle, tor, RecurrenceDaily, "2026-03-06T06:00:00Z", "2026-03-06T10:00:00Z")447 long.Description = trickyDesc448 long.Category = CategoryUpdate449450 emoji := icsWin(2, strings.Repeat("é🔧", 20), tor, RecurrenceNone, "2026-04-01T06:00:00Z", "2026-04-01T10:00:00Z")451 emoji.Description = strings.Repeat("🚀日é", 60)452453 weekly := until(icsWin(3, "Weekly, with; until", tor, RecurrenceWeekly, "2026-03-01T06:00:00Z", "2026-03-01T07:00:00Z"), "2026-12-27T07:00:00Z")454 dailyU := until(icsWin(4, "Daily until", par, RecurrenceDaily, "2026-05-01T00:30:00Z", "2026-05-01T02:00:00Z"), "2026-05-20T00:30:00Z")455 m31 := icsWin(5, "Monthly 31", tor, RecurrenceMonthly, "2026-01-31T06:00:00Z", "2026-01-31T07:00:00Z")456 m30 := icsWin(6, "Monthly 30", par, RecurrenceMonthly, "2026-01-30T06:00:00Z", "2026-01-30T07:00:00Z")457 m15 := until(icsWin(7, "Monthly 15", tor, RecurrenceMonthly, "2026-01-15T06:00:00Z", "2026-01-15T07:00:00Z"), "2026-10-15T05:00:00Z")458 m29 := icsWin(8, "Monthly 29", tor, RecurrenceMonthly, "2026-01-29T06:00:00Z", "2026-01-29T07:00:00Z")459 cancelled := icsWin(9, "Cancelled", tor, RecurrenceNone, "2026-06-01T06:00:00Z", "2026-06-01T07:00:00Z")460 cancelled.Status = StatusCancelled461 cancelled.Category = CategoryEmergency462 utcOnce := icsWin(10, "UTC once", "UTC", RecurrenceNone, "2026-07-01T12:00:00Z", "2026-07-01T13:00:00Z")463 utcDaily := icsWin(11, "UTC daily", "UTC", RecurrenceDaily, "2026-07-01T12:00:00Z", "2026-07-01T13:00:00Z")464 tokyo := icsWin(12, "Tokyo weekly", "Asia/Tokyo", RecurrenceWeekly, "2026-07-01T12:00:00Z", "2026-07-01T13:00:00Z")465 outside := icsWin(13, "Outside the range", tor, RecurrenceNone, "2024-06-01T06:00:00Z", "2024-06-01T07:00:00Z")466 ended := until(icsWin(14, "Series over", tor, RecurrenceDaily, "2024-06-01T06:00:00Z", "2024-06-01T07:00:00Z"), "2024-07-01T06:00:00Z")467 broken := icsWin(15, "Broken zone", "Mars/Olympus", RecurrenceDaily, "2026-06-01T06:00:00Z", "2026-06-01T07:00:00Z")468 return []Window{long, emoji, weekly, dailyU, m31, m30, m15, m29, cancelled, utcOnce, utcDaily, tokyo, outside, ended, broken}469}470471var (472 icsFrom = z("2026-01-01T00:00:00Z")473 icsTo = z("2027-01-01T00:00:00Z")474 icsNow = z("2026-11-18T12:34:56Z")475)476477func render(t *testing.T, ws []Window) ([]byte, *icsComp) {478 t.Helper()479 var buf bytes.Buffer480 if err := WriteICS(&buf, ws, icsFrom, icsTo, icsNow, "clustr.spboucher.ai"); err != nil {481 t.Fatalf("WriteICS: %v", err)482 }483 cal, err := parseICS(buf.Bytes())484 if err != nil {485 t.Fatalf("strict parse: %v\n%s", err, buf.String())486 }487 return buf.Bytes(), cal488}489490func eventByID(t *testing.T, cal *icsComp, n byte) *icsComp {491 t.Helper()492 uid := fmt.Sprintf("00000000-0000-4000-8000-0000000000%02x@clustr.spboucher.ai", n)493 for _, e := range cal.kids("VEVENT") {494 if e.val("UID") == uid {495 return e496 }497 }498 t.Fatalf("no VEVENT with UID %s", uid)499 return nil500}501502func TestWriteICSCalendar(t *testing.T) {503 raw, cal := render(t, sampleWindows())504505 want := map[string]string{506 "VERSION": "2.0",507 "PRODID": "-//MacLustr Command Center//Maintenance//EN",508 "CALSCALE": "GREGORIAN",509 "METHOD": "PUBLISH",510 "X-WR-CALNAME": "MacLustr Maintenance",511 }512 for k, v := range want {513 if got := cal.val(k); got != v {514 t.Errorf("%s = %q, want %q", k, got, v)515 }516 }517 if !bytes.HasPrefix(raw, []byte("BEGIN:VCALENDAR\r\nVERSION:2.0\r\n")) || !bytes.HasSuffix(raw, []byte("END:VCALENDAR\r\n")) {518 t.Errorf("bad envelope")519 }520521 // Skipped: outside the range (13), series over (14), broken zone (15).522 if n := len(cal.kids("VEVENT")); n != 12 {523 t.Fatalf("%d VEVENT, want 12", n)524 }525526 // Folding really happened, inside multi-byte text.527 folded, short := 0, 0528 for _, l := range strings.Split(string(raw), "\r\n") {529 if strings.HasPrefix(l, " ") {530 folded++531 }532 if len(l) > 70 && len(l) < 75 {533 short++534 }535 }536 if folded < 5 || short == 0 {537 t.Errorf("folded=%d short=%d: expected folds backed off before multi-byte runes", folded, short)538 }539540 // Text round trip.541 e1 := eventByID(t, cal, 1)542 if got := unescapeText(e1.val("SUMMARY")); got != longTitle {543 t.Errorf("SUMMARY round trip:\n got %q\nwant %q", got, longTitle)544 }545 if got := unescapeText(e1.val("DESCRIPTION")); got != trickyDesc {546 t.Errorf("DESCRIPTION round trip:\n got %q\nwant %q", got, trickyDesc)547 }548 if !strings.Contains(e1.val("DESCRIPTION"), `a\, b\; c\\d\nLigne`) {549 t.Errorf("DESCRIPTION escaping: %q", e1.val("DESCRIPTION"))550 }551 e2 := eventByID(t, cal, 2)552 if got := unescapeText(e2.val("SUMMARY")); got != strings.Repeat("é🔧", 20) {553 t.Errorf("emoji SUMMARY round trip: %q", got)554 }555 if got := unescapeText(e2.val("DESCRIPTION")); got != strings.Repeat("🚀日é", 60) {556 t.Errorf("emoji DESCRIPTION round trip: %q", got)557 }558 if got := unescapeText(eventByID(t, cal, 3).val("SUMMARY")); got != "Weekly, with; until" {559 t.Errorf("SUMMARY = %q", got)560 }561562 type exp struct {563 id byte564 dtstart, dtend, rrule string // "TZID|value" for zoned values565 status, categories string566 }567 cases := []exp{568 {1, "America/Toronto|20260306T010000", "America/Toronto|20260306T050000", "FREQ=DAILY", "CONFIRMED", "UPDATE"},569 {2, "|20260401T060000Z", "|20260401T100000Z", "", "CONFIRMED", "PLANNED"},570 {3, "America/Toronto|20260301T010000", "America/Toronto|20260301T020000", "FREQ=WEEKLY;UNTIL=20261227T070000Z", "CONFIRMED", "PLANNED"},571 {4, "Europe/Paris|20260501T023000", "Europe/Paris|20260501T040000", "FREQ=DAILY;UNTIL=20260520T003000Z", "CONFIRMED", "PLANNED"},572 {5, "America/Toronto|20260131T010000", "America/Toronto|20260131T020000", "FREQ=MONTHLY;BYMONTHDAY=-1", "CONFIRMED", "PLANNED"},573 {6, "Europe/Paris|20260130T070000", "Europe/Paris|20260130T080000", "FREQ=MONTHLY;BYMONTHDAY=28,29,30;BYSETPOS=-1", "CONFIRMED", "PLANNED"},574 {7, "America/Toronto|20260115T010000", "America/Toronto|20260115T020000", "FREQ=MONTHLY;UNTIL=20261015T050000Z;BYMONTHDAY=15", "CONFIRMED", "PLANNED"},575 {8, "America/Toronto|20260129T010000", "America/Toronto|20260129T020000", "FREQ=MONTHLY;BYMONTHDAY=28,29;BYSETPOS=-1", "CONFIRMED", "PLANNED"},576 {9, "|20260601T060000Z", "|20260601T070000Z", "", "CANCELLED", "EMERGENCY"},577 {10, "|20260701T120000Z", "|20260701T130000Z", "", "CONFIRMED", "PLANNED"},578 {11, "UTC|20260701T120000", "UTC|20260701T130000", "FREQ=DAILY", "CONFIRMED", "PLANNED"},579 {12, "Asia/Tokyo|20260701T210000", "Asia/Tokyo|20260701T220000", "FREQ=WEEKLY", "CONFIRMED", "PLANNED"},580 }581 zoned := func(e *icsComp, name string) string {582 p, _ := e.get(name)583 return p.params["TZID"] + "|" + p.value584 }585 for _, c := range cases {586 e := eventByID(t, cal, c.id)587 if got := zoned(e, "DTSTART"); got != c.dtstart {588 t.Errorf("event %d DTSTART = %q, want %q", c.id, got, c.dtstart)589 }590 if got := zoned(e, "DTEND"); got != c.dtend {591 t.Errorf("event %d DTEND = %q, want %q", c.id, got, c.dtend)592 }593 if got := e.val("RRULE"); got != c.rrule {594 t.Errorf("event %d RRULE = %q, want %q", c.id, got, c.rrule)595 }596 if got := e.val("STATUS"); got != c.status {597 t.Errorf("event %d STATUS = %q, want %q", c.id, got, c.status)598 }599 if got := e.val("CATEGORIES"); got != c.categories {600 t.Errorf("event %d CATEGORIES = %q, want %q", c.id, got, c.categories)601 }602 if got := e.val("DTSTAMP"); got != "20261118T123456Z" {603 t.Errorf("event %d DTSTAMP = %q", c.id, got)604 }605 if got := e.val("LAST-MODIFIED"); got != "20260203T040506Z" {606 t.Errorf("event %d LAST-MODIFIED = %q", c.id, got)607 }608 if got := e.val("TRANSP"); got != "TRANSPARENT" {609 t.Errorf("event %d TRANSP = %q", c.id, got)610 }611 _, hasDesc := e.get("DESCRIPTION")612 if hasDesc != (c.id == 1 || c.id == 2) {613 t.Errorf("event %d DESCRIPTION presence = %v", c.id, hasDesc)614 }615 }616617 // One VTIMEZONE per zone used by a recurring window, and only those.618 var zones []string619 for _, v := range cal.kids("VTIMEZONE") {620 zones = append(zones, v.val("TZID"))621 }622 if got := strings.Join(zones, ","); got != "America/Toronto,Asia/Tokyo,Europe/Paris,UTC" {623 t.Errorf("VTIMEZONE = %s", got)624 }625}626627func findObservance(tz *icsComp, kind, dtstart string) *icsComp {628 for _, o := range tz.kids(kind) {629 if o.val("DTSTART") == dtstart {630 return o631 }632 }633 return nil634}635636func TestWriteICSTimezones(t *testing.T) {637 _, cal := render(t, sampleWindows())638 tzs := map[string]*icsComp{}639 for _, v := range cal.kids("VTIMEZONE") {640 tzs[v.val("TZID")] = v641 }642643 type obs struct{ kind, dtstart, from, to, name string }644 check := func(zone string, want []obs) {645 t.Helper()646 tz := tzs[zone]647 if tz == nil {648 t.Fatalf("no VTIMEZONE %s", zone)649 }650 for _, w := range want {651 o := findObservance(tz, w.kind, w.dtstart)652 if o == nil {653 t.Errorf("%s: no %s observance at %s", zone, w.kind, w.dtstart)654 continue655 }656 if o.val("TZOFFSETFROM") != w.from || o.val("TZOFFSETTO") != w.to || o.val("TZNAME") != w.name {657 t.Errorf("%s %s %s: from %s to %s name %s, want %s %s %s", zone, w.kind, w.dtstart,658 o.val("TZOFFSETFROM"), o.val("TZOFFSETTO"), o.val("TZNAME"), w.from, w.to, w.name)659 }660 }661 }662 check("America/Toronto", []obs{663 {"DAYLIGHT", "20250309T020000", "-0500", "-0400", "EDT"},664 {"STANDARD", "20251102T020000", "-0400", "-0500", "EST"},665 {"DAYLIGHT", "20260308T020000", "-0500", "-0400", "EDT"},666 {"STANDARD", "20261101T020000", "-0400", "-0500", "EST"},667 {"DAYLIGHT", "20270314T020000", "-0500", "-0400", "EDT"},668 {"STANDARD", "20271107T020000", "-0400", "-0500", "EST"},669 })670 // Earliest Toronto DTSTART is 2026-01-15 → span 2025-01-15 .. 2028-01-01:671 // exactly 3 years of transitions.672 if n := len(tzs["America/Toronto"].children); n != 6 {673 t.Errorf("America/Toronto has %d observances, want 6", n)674 }675 check("Europe/Paris", []obs{676 {"DAYLIGHT", "20260329T020000", "+0100", "+0200", "CEST"},677 {"STANDARD", "20261025T030000", "+0200", "+0100", "CET"},678 })679 check("Asia/Tokyo", []obs{{"STANDARD", "19700101T000000", "+0900", "+0900", "JST"}})680 check("UTC", []obs{{"STANDARD", "19700101T000000", "+0000", "+0000", "UTC"}})681 for _, zone := range []string{"Asia/Tokyo", "UTC"} {682 if n := len(tzs[zone].children); n != 1 {683 t.Errorf("%s has %d observances, want 1", zone, n)684 }685 }686687 // Observances are in chronological order.688 for zone, tz := range tzs {689 prev := ""690 for _, o := range tz.children {691 if o.val("DTSTART") <= prev {692 t.Errorf("%s: observances not ordered", zone)693 }694 prev = o.val("DTSTART")695 }696 }697}698699func TestWriteICSObservanceCap(t *testing.T) {700 // A daily window created in 1900: far more than 200 transitions.701 w := icsWin(1, "Old", "America/Toronto", RecurrenceDaily, "1900-01-01T06:00:00Z", "1900-01-01T07:00:00Z")702 _, cal := render(t, []Window{w})703 tz := cal.kids("VTIMEZONE")704 if len(tz) != 1 {705 t.Fatalf("%d VTIMEZONE", len(tz))706 }707 if n := len(tz[0].children); n != maxObservances {708 t.Fatalf("%d observances, want %d", n, maxObservances)709 }710 // The most recent ones are kept.711 if findObservance(tz[0], "STANDARD", "20261101T020000") == nil {712 t.Fatal("recent transition missing after capping")713 }714}715716func TestWriteICSStableAndEmpty(t *testing.T) {717 ws := sampleWindows()718 a, calA := render(t, ws)719 b, calB := render(t, ws)720 if !bytes.Equal(a, b) {721 t.Fatal("output differs between two calls")722 }723 ea, eb := calA.kids("VEVENT"), calB.kids("VEVENT")724 for i := range ea {725 if ea[i].val("UID") != eb[i].val("UID") {726 t.Fatalf("UID %d not stable", i)727 }728 if want := ws[i].ID.String() + "@clustr.spboucher.ai"; ea[i].val("UID") != want {729 t.Fatalf("UID %d = %q, want %q", i, ea[i].val("UID"), want)730 }731 }732 // UIDs do not depend on now or on the range.733 var buf bytes.Buffer734 if err := WriteICS(&buf, ws, z("2026-06-01T00:00:00Z"), z("2026-06-02T00:00:00Z"), z("2030-01-01T00:00:00Z"), "clustr.spboucher.ai"); err != nil {735 t.Fatal(err)736 }737 calC, err := parseICS(buf.Bytes())738 if err != nil {739 t.Fatal(err)740 }741 uids := map[string]bool{}742 for _, e := range ea {743 uids[e.val("UID")] = true744 }745 // In that one-day range: daily Toronto (1), weekly (3)? no (Mon), the746 // cancelled one (9); every UID must be one of the stable ones.747 if len(calC.kids("VEVENT")) == 0 {748 t.Fatal("no event in the narrow range")749 }750 for _, e := range calC.kids("VEVENT") {751 if !uids[e.val("UID")] {752 t.Fatalf("unknown UID %s", e.val("UID"))753 }754 }755 if eventByID(t, calC, 9).val("STATUS") != "CANCELLED" {756 t.Fatal("cancelled window missing in narrow range")757 }758759 // Duplicate window IDs are emitted once.760 _, calD := render(t, []Window{ws[0], ws[0]})761 if n := len(calD.kids("VEVENT")); n != 1 {762 t.Fatalf("%d VEVENT for a duplicated window", n)763 }764765 // Empty calendar is still a valid calendar.766 raw, calE := render(t, nil)767 if len(calE.children) != 0 {768 t.Fatalf("empty calendar has components:\n%s", raw)769 }770}771772type failWriter struct{}773774func (failWriter) Write([]byte) (int, error) { return 0, errors.New("boom") }775776func TestWriteICSWriterError(t *testing.T) {777 if err := WriteICS(failWriter{}, sampleWindows(), icsFrom, icsTo, icsNow, "x"); err == nil {778 t.Fatal("expected the writer error")779 }780}781782func TestFoldAndEscape(t *testing.T) {783 inputs := []string{784 "",785 "short",786 strings.Repeat("a", 75),787 strings.Repeat("a", 76),788 strings.Repeat("a", 75+74),789 strings.Repeat("a", 75+74+1),790 "SUMMARY:" + strings.Repeat("é", 100),791 "SUMMARY:" + strings.Repeat("🔧", 100),792 "X:" + strings.Repeat("a🔧é日", 50),793 }794 for _, in := range inputs {795 var b bytes.Buffer796 writeFolded(&b, in)797 out := b.String()798 if !strings.HasSuffix(out, "\r\n") {799 t.Fatalf("no CRLF for %q", in)800 }801 lines := strings.Split(strings.TrimSuffix(out, "\r\n"), "\r\n")802 var un strings.Builder803 for i, l := range lines {804 if len(l) > 75 {805 t.Fatalf("line of %d octets for %q", len(l), in)806 }807 if !utf8.ValidString(l) {808 t.Fatalf("split UTF-8 for %q", in)809 }810 if i > 0 {811 if !strings.HasPrefix(l, " ") || len(l) < 2 {812 t.Fatalf("bad continuation %q", l)813 }814 l = l[1:]815 }816 un.WriteString(l)817 }818 if un.String() != in {819 t.Fatalf("unfold mismatch for %q", in)820 }821 }822823 esc := map[string]string{824 "a,b;c\\d": `a\,b\;c\\d`,825 "l1\nl2\r\nl3\rl4": `l1\nl2\nl3\nl4`,826 "bell\x07tab\tend": "belltab\tend",827 "bad\xffutf8": "bad�utf8",828 }829 for in, want := range esc {830 if got := escapeText(in); got != want {831 t.Errorf("escapeText(%q) = %q, want %q", in, got, want)832 }833 }834 if got := formatOffset(-12600); got != "-0330" {835 t.Errorf("formatOffset = %q", got)836 }837 if got := formatOffset(20700 + 8); got != "+054508" {838 t.Errorf("formatOffset = %q", got)839 }840}841