70745bb577
- Show non-blocking prompt card when ambient confidence drops below 0.6 for >5 minutes
- Add 'Diagnose' button that fetches and displays root cause analysis
- Add 'Dismiss for today' option with localStorage persistence
- Implement pulsing amber highlight on 3D link lines for degraded links
- Display diagnostic results in plain English with possible causes and actions
- Do NOT show prompts for transient drops (< 5 minutes)
- Add GetDiagnosticFor method to diagnostics package for timestamp-based queries
- Wire up /api/links/{linkID}/diagnostics endpoint with health snapshots
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2413 lines
60 KiB
Go
2413 lines
60 KiB
Go
package notifications
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// Helper function to create a manager with quiet hours disabled for testing.
|
|
// This ensures batching tests work regardless of when they run.
|
|
func newTestManagerWithQuietHoursDisabled(cfg Config) (*NotificationManager, error) {
|
|
m, err := New(cfg)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Disable quiet hours by setting bitmask to 0 (no days)
|
|
err = m.SetConfig(NotificationConfig{
|
|
Channel: "test",
|
|
QuietFrom: "00:00",
|
|
QuietTo: "00:00",
|
|
QuietDaysBitmask: 0, // Disabled - no days selected
|
|
MorningDigest: false,
|
|
})
|
|
if err != nil {
|
|
m.Close()
|
|
return nil, err
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
// TestNewManager tests creating a new notification manager.
|
|
func TestNewManager(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
m, err := New(Config{DBPath: dbPath})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
if m == nil {
|
|
t.Fatal("New() returned nil")
|
|
}
|
|
}
|
|
|
|
// TestNewManagerErrors tests error cases for New.
|
|
func TestNewManagerErrors(t *testing.T) {
|
|
t.Run("empty DBPath", func(t *testing.T) {
|
|
_, err := New(Config{})
|
|
if err == nil {
|
|
t.Error("New() with empty DBPath should return error")
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestConfigPersistence tests saving and loading configuration.
|
|
func TestConfigPersistence(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
m, err := New(Config{DBPath: dbPath})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set custom config
|
|
cfg := NotificationConfig{
|
|
Channel: "test-channel",
|
|
QuietFrom: "23:00",
|
|
QuietTo: "06:00",
|
|
QuietDaysBitmask: 0x1F, // Mon-Fri only
|
|
MorningDigest: false,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Get config and verify
|
|
retrieved := m.GetConfig()
|
|
if retrieved.Channel != "test-channel" {
|
|
t.Errorf("Channel = %s, want test-channel", retrieved.Channel)
|
|
}
|
|
if retrieved.QuietFrom != "23:00" {
|
|
t.Errorf("QuietFrom = %s, want 23:00", retrieved.QuietFrom)
|
|
}
|
|
if retrieved.QuietTo != "06:00" {
|
|
t.Errorf("QuietTo = %s, want 06:00", retrieved.QuietTo)
|
|
}
|
|
if retrieved.QuietDaysBitmask != 0x1F {
|
|
t.Errorf("QuietDaysBitmask = %x, want 1f", retrieved.QuietDaysBitmask)
|
|
}
|
|
if retrieved.MorningDigest {
|
|
t.Error("MorningDigest = true, want false")
|
|
}
|
|
}
|
|
|
|
// TestPriorityString tests the Priority String method.
|
|
func TestPriorityString(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
priority Priority
|
|
want string
|
|
}{
|
|
{"LOW", Low, "LOW"},
|
|
{"MEDIUM", Medium, "MEDIUM"},
|
|
{"HIGH", High, "HIGH"},
|
|
{"URGENT", Urgent, "URGENT"},
|
|
{"UNKNOWN", Priority(99), "UNKNOWN"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := tt.priority.String(); got != tt.want {
|
|
t.Errorf("Priority.String() = %s, want %s", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestNotifyUrgentImmediate tests that urgent notifications are sent immediately.
|
|
func TestNotifyUrgentImmediate(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
SendCallback: func(e Event) { receivedEvent = e },
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
event := Event{
|
|
Type: FallDetected,
|
|
Priority: Urgent,
|
|
Title: "Fall Detected",
|
|
Body: "Fall detected in hallway",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// Verify callback was called
|
|
if receivedEvent.Type != FallDetected {
|
|
t.Errorf("received event Type = %s, want FallDetected", receivedEvent.Type)
|
|
}
|
|
if receivedEvent.Priority != Urgent {
|
|
t.Errorf("received event Priority = %d, want Urgent", receivedEvent.Priority)
|
|
}
|
|
if receivedEvent.Title != "Fall Detected" {
|
|
t.Errorf("received event Title = %s, want 'Fall Detected'", receivedEvent.Title)
|
|
}
|
|
}
|
|
|
|
// TestNotifyHighImmediate tests that high priority notifications are sent immediately.
|
|
func TestNotifyHighImmediate(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedEvent Event
|
|
m, err := newTestManagerWithQuietHoursDisabled(Config{
|
|
DBPath: dbPath,
|
|
SendCallback: func(e Event) { receivedEvent = e },
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
event := Event{
|
|
Type: AnomalyAlert,
|
|
Priority: High,
|
|
Title: "Anomaly Alert",
|
|
Body: "Unusual activity detected",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
if receivedEvent.Type != AnomalyAlert {
|
|
t.Errorf("received event Type = %s, want AnomalyAlert", receivedEvent.Type)
|
|
}
|
|
}
|
|
|
|
// TestBatching tests that LOW and MEDIUM events are batched.
|
|
func TestBatching(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedEvents []Event
|
|
m, err := newTestManagerWithQuietHoursDisabled(Config{
|
|
DBPath: dbPath,
|
|
BatchWindowSec: 1, // Short window for testing
|
|
SendCallback: func(e Event) { receivedEvents = append(receivedEvents, e) },
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Send multiple low priority events
|
|
for i := 0; i < 3; i++ {
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Test Event",
|
|
Body: "Test message",
|
|
}
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Logf("Notify() %d error = %v", i, err)
|
|
}
|
|
}
|
|
|
|
// Events should be queued, not sent immediately
|
|
if len(receivedEvents) != 0 {
|
|
t.Errorf("got %d events sent immediately, want 0", len(receivedEvents))
|
|
}
|
|
|
|
// Wait for batch window
|
|
time.Sleep(1500 * time.Millisecond)
|
|
|
|
// Check pending count is now 0
|
|
low, medium, _ := m.GetPendingCount()
|
|
if low != 0 {
|
|
t.Errorf("pendingLow = %d, want 0", low)
|
|
}
|
|
if medium != 0 {
|
|
t.Errorf("pendingMedium = %d, want 0", medium)
|
|
}
|
|
|
|
// Should have received a summary event
|
|
if len(receivedEvents) == 0 {
|
|
t.Fatal("no events received after batch window")
|
|
}
|
|
|
|
summary := receivedEvents[0]
|
|
if summary.Data["is_batch"] != true {
|
|
t.Error("received event is not marked as batch")
|
|
}
|
|
}
|
|
|
|
// TestBatchMaxSize tests that batch is flushed when max size is reached.
|
|
func TestBatchMaxSize(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedEvents []Event
|
|
m, err := newTestManagerWithQuietHoursDisabled(Config{
|
|
DBPath: dbPath,
|
|
MaxBatchSize: 3,
|
|
SendCallback: func(e Event) { receivedEvents = append(receivedEvents, e) },
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Send exactly max batch size events
|
|
for i := 0; i < 3; i++ {
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Test Event",
|
|
Body: "Test message",
|
|
}
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Logf("Notify() %d error = %v", i, err)
|
|
}
|
|
}
|
|
|
|
// Should have triggered immediate flush due to max batch size
|
|
// Give a moment for the goroutine to run
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
if len(receivedEvents) == 0 {
|
|
t.Error("no events received after max batch size reached")
|
|
}
|
|
}
|
|
|
|
// TestQuietHoursQueueing tests that LOW/MEDIUM events are queued during quiet hours.
|
|
func TestQuietHoursQueueing(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to cover current time
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "00:00",
|
|
QuietTo: "23:59",
|
|
QuietDaysBitmask: 0xFF, // All days
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Send low priority event during quiet hours
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Test Event",
|
|
Body: "Should be queued",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// Verify it was queued for digest
|
|
low, medium, digest := m.GetPendingCount()
|
|
if low != 0 {
|
|
t.Errorf("pendingLow = %d, want 0 (should be in digest queue)", low)
|
|
}
|
|
if medium != 0 {
|
|
t.Errorf("pendingMedium = %d, want 0", medium)
|
|
}
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1", digest)
|
|
}
|
|
}
|
|
|
|
// TestQuietHoursHighPriority tests that HIGH events respect quiet hours (queued for digest).
|
|
func TestQuietHoursHighPriority(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
t.Error("HIGH event callback should not be called during quiet hours")
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to cover current time
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "00:00",
|
|
QuietTo: "23:59",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Send high priority event during quiet hours
|
|
event := Event{
|
|
Type: FallDetected,
|
|
Priority: High,
|
|
Title: "High Priority Event",
|
|
Body: "Should be queued for digest (respects quiet hours)",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// HIGH bypasses batching but respects quiet hours - should be queued for digest
|
|
low, medium, digest := m.GetPendingCount()
|
|
if low != 0 {
|
|
t.Errorf("pendingLow = %d, want 0", low)
|
|
}
|
|
if medium != 0 {
|
|
t.Errorf("pendingMedium = %d, want 0", medium)
|
|
}
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1 (HIGH respects quiet hours)", digest)
|
|
}
|
|
}
|
|
|
|
// TestUrgentBypassesAll tests that URGENT events bypass both batching and quiet hours.
|
|
func TestUrgentBypassesAll(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) { receivedEvent = e },
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours and enable batching
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "00:00",
|
|
QuietTo: "23:59",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Send urgent event during quiet hours
|
|
event := Event{
|
|
Type: FallEscalation,
|
|
Priority: Urgent,
|
|
Title: "URGENT: Fall Escalation",
|
|
Body: "Immediate action required",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// Verify it was sent immediately
|
|
if receivedEvent.Type != FallEscalation {
|
|
t.Errorf("received event Type = %s, want FallEscalation", receivedEvent.Type)
|
|
}
|
|
if receivedEvent.Priority != Urgent {
|
|
t.Errorf("received event Priority = %d, want Urgent", receivedEvent.Priority)
|
|
}
|
|
|
|
// Should not be in any queue
|
|
low, medium, digest := m.GetPendingCount()
|
|
if low != 0 || medium != 0 || digest != 0 {
|
|
t.Errorf("Events queued (low=%d, medium=%d, digest=%d), want all 0", low, medium, digest)
|
|
}
|
|
}
|
|
|
|
// TestQuietDaysBitmask tests that quiet hours only apply on specified days.
|
|
func TestQuietDaysBitmask(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
now := time.Now().In(loc)
|
|
currentDayMask := uint8(1 << now.Weekday())
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours for only the current day
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "00:00",
|
|
QuietTo: "23:59",
|
|
QuietDaysBitmask: currentDayMask,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Send low priority event
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Test Event",
|
|
Body: "Should be queued",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// Should be queued (current day is in quiet hours)
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1 (current day should be in quiet hours)", digest)
|
|
}
|
|
}
|
|
|
|
// TestMediumPriorityBatching tests that MEDIUM priority events are batched.
|
|
func TestMediumPriorityBatching(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedEvents []Event
|
|
m, err := newTestManagerWithQuietHoursDisabled(Config{
|
|
DBPath: dbPath,
|
|
BatchWindowSec: 1,
|
|
SendCallback: func(e Event) { receivedEvents = append(receivedEvents, e) },
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Send medium priority events
|
|
for i := 0; i < 2; i++ {
|
|
event := Event{
|
|
Type: ZoneLeave,
|
|
Priority: Medium,
|
|
Title: "Medium Event",
|
|
Body: "Test message",
|
|
}
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Logf("Notify() %d error = %v", i, err)
|
|
}
|
|
}
|
|
|
|
// Events should be queued
|
|
_, medium, _ := m.GetPendingCount()
|
|
if medium != 2 {
|
|
t.Errorf("pendingMedium = %d, want 2", medium)
|
|
}
|
|
|
|
// Wait for batch window
|
|
time.Sleep(1500 * time.Millisecond)
|
|
|
|
// Should be flushed now
|
|
_, medium, _ = m.GetPendingCount()
|
|
if medium != 0 {
|
|
t.Errorf("pendingMedium = %d, want 0 after flush", medium)
|
|
}
|
|
}
|
|
|
|
// TestGetHistory tests retrieving notification history.
|
|
func TestGetHistory(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
m, err := newTestManagerWithQuietHoursDisabled(Config{
|
|
DBPath: dbPath,
|
|
BatchWindowSec: 1, // Short batch window for testing
|
|
SendCallback: func(e Event) {},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Send some events - Urgent is sent immediately, Low/Medium are batched
|
|
events := []Event{
|
|
{Type: ZoneEnter, Priority: Low, Title: "Event 1", Body: "Body 1"},
|
|
{Type: ZoneLeave, Priority: Medium, Title: "Event 2", Body: "Body 2"},
|
|
{Type: FallDetected, Priority: Urgent, Title: "Event 3", Body: "Body 3"},
|
|
}
|
|
|
|
for _, e := range events {
|
|
if err := m.Notify(e); err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
}
|
|
|
|
// Wait for batch window to flush batched events
|
|
time.Sleep(1500 * time.Millisecond)
|
|
|
|
// Get history
|
|
history, err := m.GetHistory(10)
|
|
if err != nil {
|
|
t.Fatalf("GetHistory() error = %v", err)
|
|
}
|
|
|
|
if len(history) != 3 {
|
|
t.Fatalf("GetHistory() returned %d events, want 3", len(history))
|
|
}
|
|
|
|
// Verify events (should be in reverse chronological order)
|
|
// Urgent (Event 3) is sent first, then batched events (Event 1, Event 2)
|
|
// The batch summary comes after the urgent event
|
|
if history[0]["title"] != "Event 3" {
|
|
t.Errorf("history[0].title = %s, want Event 3", history[0]["title"])
|
|
}
|
|
|
|
// Check that urgent event was not batched or queued
|
|
if history[0]["was_batched"] != false {
|
|
t.Error("Urgent event was marked as batched")
|
|
}
|
|
if history[0]["was_queued"] != false {
|
|
t.Error("Urgent event was marked as queued")
|
|
}
|
|
|
|
// The batch summary should have was_batched=true
|
|
batchFound := false
|
|
for i := 1; i < len(history); i++ {
|
|
if history[i]["was_batched"] == true {
|
|
batchFound = true
|
|
break
|
|
}
|
|
}
|
|
if !batchFound {
|
|
t.Error("No batched event found in history")
|
|
}
|
|
}
|
|
|
|
// TestFlush tests manually flushing pending notifications.
|
|
func TestFlush(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedEvents []Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
SendCallback: func(e Event) { receivedEvents = append(receivedEvents, e) },
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to queue events
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "00:00",
|
|
QuietTo: "23:59",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
m.SetConfig(cfg)
|
|
|
|
// Send some events
|
|
for i := 0; i < 3; i++ {
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Test Event",
|
|
Body: "Should be queued",
|
|
}
|
|
m.Notify(event)
|
|
}
|
|
|
|
// Verify events are queued
|
|
low, medium, digest := m.GetPendingCount()
|
|
if digest != 3 {
|
|
t.Errorf("queuedForDigest = %d, want 3", digest)
|
|
}
|
|
|
|
// Flush
|
|
m.Flush()
|
|
|
|
// Verify events were sent
|
|
if len(receivedEvents) != 3 {
|
|
t.Errorf("received %d events, want 3", len(receivedEvents))
|
|
}
|
|
|
|
// Verify queues are empty
|
|
low, medium, digest = m.GetPendingCount()
|
|
if low != 0 || medium != 0 || digest != 0 {
|
|
t.Errorf("Queues not empty after flush: low=%d, medium=%d, digest=%d", low, medium, digest)
|
|
}
|
|
}
|
|
|
|
// TestCreateSummary tests the summary creation logic.
|
|
func TestCreateSummary(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
m, err := New(Config{DBPath: dbPath})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
events := []*Event{
|
|
{Type: ZoneEnter, Priority: Low, Title: "Event 1"},
|
|
{Type: ZoneEnter, Priority: Low, Title: "Event 2"},
|
|
{Type: ZoneLeave, Priority: Low, Title: "Event 3"},
|
|
{Type: ZoneVacant, Priority: Low, Title: "Event 4"},
|
|
{Type: NodeOffline, Priority: Low, Title: "Event 5"},
|
|
}
|
|
|
|
summary := m.createSummary(events)
|
|
|
|
if summary.Data["is_batch"] != true {
|
|
t.Error("Summary not marked as batch")
|
|
}
|
|
|
|
eventCount, ok := summary.Data["event_count"].(int)
|
|
if !ok || eventCount != 5 {
|
|
t.Errorf("event_count = %v, want 5", summary.Data["event_count"])
|
|
}
|
|
|
|
// Check title contains count
|
|
if summary.Title != "Activity Update: 5 events" {
|
|
t.Errorf("Title = %s, want 'Activity Update: 5 events'", summary.Title)
|
|
}
|
|
}
|
|
|
|
// TestSingleEventBatch tests that a single event in a batch is sent directly.
|
|
func TestSingleEventBatch(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedEvent Event
|
|
m, err := newTestManagerWithQuietHoursDisabled(Config{
|
|
DBPath: dbPath,
|
|
BatchWindowSec: 1,
|
|
SendCallback: func(e Event) { receivedEvent = e },
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Single Event",
|
|
Body: "Only one event",
|
|
}
|
|
|
|
m.Notify(event)
|
|
time.Sleep(1500 * time.Millisecond)
|
|
|
|
// Single event should be sent as-is, not as a summary
|
|
if receivedEvent.Title != "Single Event" {
|
|
t.Errorf("Title = %s, want 'Single Event'", receivedEvent.Title)
|
|
}
|
|
|
|
if receivedEvent.Data["is_batch"] == true {
|
|
t.Error("Single event was marked as batch")
|
|
}
|
|
}
|
|
|
|
// TestNotifyWithTimestamp tests that events with timestamps preserve them.
|
|
func TestNotifyWithTimestamp(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
SendCallback: func(e Event) { receivedEvent = e },
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
expectedTime := time.Date(2024, 4, 10, 12, 30, 0, 0, time.UTC)
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Urgent,
|
|
Title: "Test",
|
|
Body: "Test",
|
|
Timestamp: expectedTime,
|
|
}
|
|
|
|
m.Notify(event)
|
|
|
|
if !receivedEvent.Timestamp.Equal(expectedTime) {
|
|
t.Errorf("Timestamp = %v, want %v", receivedEvent.Timestamp, expectedTime)
|
|
}
|
|
}
|
|
|
|
// TestGetPendingCount tests getting pending notification counts.
|
|
func TestGetPendingCount(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Initially all zeros
|
|
low, medium, digest := m.GetPendingCount()
|
|
if low != 0 || medium != 0 || digest != 0 {
|
|
t.Errorf("Initial counts not zero: low=%d, medium=%d, digest=%d", low, medium, digest)
|
|
}
|
|
|
|
// Set quiet hours to queue events
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "00:00",
|
|
QuietTo: "23:59",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
m.SetConfig(cfg)
|
|
|
|
// Add events to each queue
|
|
m.Notify(Event{Type: ZoneEnter, Priority: Low, Title: "Low"})
|
|
m.Notify(Event{Type: ZoneLeave, Priority: Medium, Title: "Medium"})
|
|
|
|
low, medium, digest = m.GetPendingCount()
|
|
if low != 0 {
|
|
t.Errorf("pendingLow = %d, want 0 (low priority goes to digest during quiet hours)", low)
|
|
}
|
|
if medium != 0 {
|
|
t.Errorf("pendingMedium = %d, want 0 (medium priority goes to digest during quiet hours)", medium)
|
|
}
|
|
if digest != 2 {
|
|
t.Errorf("queuedForDigest = %d, want 2", digest)
|
|
}
|
|
}
|
|
|
|
// TestSetAndGetConfig tests getting and setting configuration.
|
|
func TestSetAndGetConfig(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
m, err := New(Config{DBPath: dbPath})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Test default config
|
|
defaultCfg := m.GetConfig()
|
|
if defaultCfg.Channel != "default" {
|
|
t.Errorf("Default Channel = %s, want 'default'", defaultCfg.Channel)
|
|
}
|
|
if defaultCfg.QuietFrom != "22:00" {
|
|
t.Errorf("Default QuietFrom = %s, want '22:00'", defaultCfg.QuietFrom)
|
|
}
|
|
if defaultCfg.QuietTo != "07:00" {
|
|
t.Errorf("Default QuietTo = %s, want '07:00'", defaultCfg.QuietTo)
|
|
}
|
|
|
|
// Set custom config
|
|
customCfg := NotificationConfig{
|
|
Channel: "custom",
|
|
QuietFrom: "21:30",
|
|
QuietTo: "08:30",
|
|
QuietDaysBitmask: 0x07, // Sun-Tue only
|
|
MorningDigest: false,
|
|
}
|
|
|
|
err = m.SetConfig(customCfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
retrieved := m.GetConfig()
|
|
if retrieved.Channel != "custom" {
|
|
t.Errorf("Channel = %s, want 'custom'", retrieved.Channel)
|
|
}
|
|
if retrieved.QuietFrom != "21:30" {
|
|
t.Errorf("QuietFrom = %s, want '21:30'", retrieved.QuietFrom)
|
|
}
|
|
if retrieved.QuietTo != "08:30" {
|
|
t.Errorf("QuietTo = %s, want '08:30'", retrieved.QuietTo)
|
|
}
|
|
if retrieved.QuietDaysBitmask != 0x07 {
|
|
t.Errorf("QuietDaysBitmask = %x, want 07", retrieved.QuietDaysBitmask)
|
|
}
|
|
if retrieved.MorningDigest {
|
|
t.Error("MorningDigest = true, want false")
|
|
}
|
|
}
|
|
|
|
// TestEventTypes tests all event type constants.
|
|
func TestEventTypes(t *testing.T) {
|
|
types := []EventType{
|
|
ZoneEnter,
|
|
ZoneLeave,
|
|
ZoneVacant,
|
|
FallDetected,
|
|
FallEscalation,
|
|
AnomalyAlert,
|
|
NodeOffline,
|
|
SleepSummary,
|
|
}
|
|
|
|
for _, tpe := range types {
|
|
if tpe == "" {
|
|
t.Errorf("Event type %v is empty", tpe)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestSetSendCallback tests setting the send callback.
|
|
func TestSetSendCallback(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var callbackCalled bool
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set callback after creation
|
|
m.SetSendCallback(func(e Event) {
|
|
callbackCalled = true
|
|
})
|
|
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Urgent,
|
|
Title: "Test",
|
|
Body: "Test",
|
|
}
|
|
|
|
m.Notify(event)
|
|
|
|
if !callbackCalled {
|
|
t.Error("Callback was not called")
|
|
}
|
|
}
|
|
|
|
// TestBatchingThreeLowEvents tests that 3 LOW events within batch window produce 1 notification.
|
|
func TestBatchingThreeLowEvents(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedCount int
|
|
var receivedEvent Event
|
|
m, err := newTestManagerWithQuietHoursDisabled(Config{
|
|
DBPath: dbPath,
|
|
BatchWindowSec: 10, // 10 second batch window
|
|
SendCallback: func(e Event) {
|
|
receivedCount++
|
|
receivedEvent = e
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Send 3 LOW events rapidly (within 1 second)
|
|
for i := 0; i < 3; i++ {
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: fmt.Sprintf("Low Event %d", i),
|
|
Body: "Test message",
|
|
}
|
|
err := m.Notify(event)
|
|
if err != nil {
|
|
t.Logf("Notify() %d error = %v", i, err)
|
|
}
|
|
}
|
|
|
|
// Events should be queued, not sent immediately
|
|
if receivedCount != 0 {
|
|
t.Errorf("got %d events sent immediately, want 0", receivedCount)
|
|
}
|
|
|
|
// Check pending count
|
|
low, medium, digest := m.GetPendingCount()
|
|
if low != 3 {
|
|
t.Errorf("pendingLow = %d, want 3", low)
|
|
}
|
|
if medium != 0 {
|
|
t.Errorf("pendingMedium = %d, want 0", medium)
|
|
}
|
|
if digest != 0 {
|
|
t.Errorf("queuedForDigest = %d, want 0", digest)
|
|
}
|
|
|
|
// Wait for batch window to expire
|
|
time.Sleep(11 * time.Second)
|
|
|
|
// Now should have received a batch summary
|
|
if receivedCount != 1 {
|
|
t.Errorf("received %d events after batch window, want 1", receivedCount)
|
|
}
|
|
|
|
// Verify it was a batch
|
|
if receivedEvent.Data["is_batch"] != true {
|
|
t.Error("Received event is not marked as batch")
|
|
}
|
|
|
|
eventCount, ok := receivedEvent.Data["event_count"].(int)
|
|
if !ok || eventCount != 3 {
|
|
t.Errorf("event_count = %v, want 3", receivedEvent.Data["event_count"])
|
|
}
|
|
}
|
|
|
|
// TestBatchingUrgentBypassesBatch tests that URGENT events are sent immediately.
|
|
func TestBatchingUrgentBypassesBatch(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedEvents []Event
|
|
m, err := newTestManagerWithQuietHoursDisabled(Config{
|
|
DBPath: dbPath,
|
|
BatchWindowSec: 30,
|
|
SendCallback: func(e Event) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Send some LOW events first
|
|
for i := 0; i < 2; i++ {
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: fmt.Sprintf("Low Event %d", i),
|
|
Body: "Test",
|
|
}
|
|
m.Notify(event)
|
|
}
|
|
|
|
// Verify LOW events are queued
|
|
low, _, _ := m.GetPendingCount()
|
|
if low != 2 {
|
|
t.Errorf("pendingLow = %d, want 2", low)
|
|
}
|
|
|
|
// Send URGENT event - should bypass batching
|
|
urgentEvent := Event{
|
|
Type: FallDetected,
|
|
Priority: Urgent,
|
|
Title: "FALL DETECTED",
|
|
Body: "Immediate action required",
|
|
}
|
|
|
|
err = m.Notify(urgentEvent)
|
|
if err != nil {
|
|
t.Fatalf("Notify() urgent error = %v", err)
|
|
}
|
|
|
|
// URGENT should have been sent immediately
|
|
if len(receivedEvents) != 1 {
|
|
t.Fatalf("received %d events, want 1 (URGENT)", len(receivedEvents))
|
|
}
|
|
|
|
if receivedEvents[0].Type != FallDetected {
|
|
t.Errorf("Received type = %s, want FallDetected", receivedEvents[0].Type)
|
|
}
|
|
|
|
if receivedEvents[0].Priority != Urgent {
|
|
t.Errorf("Received priority = %d, want Urgent", receivedEvents[0].Priority)
|
|
}
|
|
|
|
// LOW events should still be queued
|
|
low, _, _ = m.GetPendingCount()
|
|
if low != 2 {
|
|
t.Errorf("pendingLow = %d after URGENT, want 2 (LOW events still queued)", low)
|
|
}
|
|
}
|
|
|
|
// TestQuietHoursLowQueued tests LOW event at 23:00 is queued during quiet hours.
|
|
func TestQuietHoursLowQueued(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
// Use a fixed timezone for predictable testing
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to 22:00-07:00
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "22:00",
|
|
QuietTo: "07:00",
|
|
QuietDaysBitmask: 0xFF, // All days
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Mock current time to 23:00 (within quiet hours)
|
|
// Since we can't actually control time, we'll set quiet hours to cover current time
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
// Set quiet hours to include current time
|
|
quietFrom := fmt.Sprintf("%02d:%02d", currentHour, currentMinute)
|
|
quietTo := fmt.Sprintf("%02d:%02d", (currentHour+1)%24, currentMinute)
|
|
|
|
cfg.QuietFrom = quietFrom
|
|
cfg.QuietTo = quietTo
|
|
m.SetConfig(cfg)
|
|
|
|
// Send LOW priority event during quiet hours
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Late Night Activity",
|
|
Body: "Should be queued for morning digest",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// Verify LOW event was queued for digest, not sent
|
|
low, medium, digest := m.GetPendingCount()
|
|
if low != 0 {
|
|
t.Errorf("pendingLow = %d, want 0 (LOW goes to digest during quiet hours)", low)
|
|
}
|
|
if medium != 0 {
|
|
t.Errorf("pendingMedium = %d, want 0", medium)
|
|
}
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1", digest)
|
|
}
|
|
}
|
|
|
|
// TestQuietHoursUrgentDelivered tests URGENT event at 23:00 is delivered immediately.
|
|
func TestQuietHoursUrgentDelivered(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvent = e
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to cover current time
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: fmt.Sprintf("%02d:%02d", currentHour, currentMinute),
|
|
QuietTo: fmt.Sprintf("%02d:%02d", (currentHour+1)%24, currentMinute),
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Send URGENT priority event during quiet hours
|
|
event := Event{
|
|
Type: FallDetected,
|
|
Priority: Urgent,
|
|
Title: "FALL DETECTED",
|
|
Body: "Immediate action required - bypasses quiet hours",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// Verify URGENT was sent immediately
|
|
if receivedEvent.Type != FallDetected {
|
|
t.Errorf("Received type = %s, want FallDetected", receivedEvent.Type)
|
|
}
|
|
|
|
if receivedEvent.Priority != Urgent {
|
|
t.Errorf("Received priority = %d, want Urgent", receivedEvent.Priority)
|
|
}
|
|
|
|
// Should not be in any queue
|
|
low, medium, digest := m.GetPendingCount()
|
|
if low != 0 || medium != 0 || digest != 0 {
|
|
t.Errorf("Events queued (low=%d, medium=%d, digest=%d), want all 0", low, medium, digest)
|
|
}
|
|
}
|
|
|
|
// TestMorningDigestDelivery tests morning digest bundles queued events at quiet_hours_end.
|
|
func TestMorningDigestDelivery(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvents []Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Enable morning digest
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "22:00",
|
|
QuietTo: "07:00",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Queue some events by setting quiet hours to cover current time
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg.QuietFrom = fmt.Sprintf("%02d:%02d", currentHour, currentMinute)
|
|
cfg.QuietTo = fmt.Sprintf("%02d:%02d", (currentHour+2)%24, currentMinute)
|
|
m.SetConfig(cfg)
|
|
|
|
// Queue multiple LOW events
|
|
for i := 0; i < 3; i++ {
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: fmt.Sprintf("Night Event %d", i),
|
|
Body: "Activity during quiet hours",
|
|
}
|
|
m.Notify(event)
|
|
}
|
|
|
|
// Verify events are queued
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 3 {
|
|
t.Errorf("queuedForDigest = %d, want 3", digest)
|
|
}
|
|
|
|
// Manually trigger digest (simulating quiet_hours_end)
|
|
// In real operation, this would happen automatically at quiet_hours_end
|
|
m.sendDigest()
|
|
|
|
// Verify digest was sent
|
|
if len(receivedEvents) != 1 {
|
|
t.Fatalf("received %d events, want 1 (digest)", len(receivedEvents))
|
|
}
|
|
|
|
digestEvent := receivedEvents[0]
|
|
if digestEvent.Data["is_digest"] != true {
|
|
t.Error("Received event is not marked as digest")
|
|
}
|
|
|
|
eventCount, ok := digestEvent.Data["event_count"].(int)
|
|
if !ok || eventCount != 3 {
|
|
t.Errorf("event_count = %v, want 3", digestEvent.Data["event_count"])
|
|
}
|
|
|
|
// Verify queue is empty after digest
|
|
_, _, digest = m.GetPendingCount()
|
|
if digest != 0 {
|
|
t.Errorf("queuedForDigest = %d after digest, want 0", digest)
|
|
}
|
|
}
|
|
|
|
// TestMorningDigestNotSentWhenDisabled tests digest is not sent when disabled.
|
|
func TestMorningDigestNotSentWhenDisabled(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvents []Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvents = append(receivedEvents, e)
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Disable morning digest
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "22:00",
|
|
QuietTo: "07:00",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: false, // Disabled
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Set quiet hours to queue events
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg.QuietFrom = fmt.Sprintf("%02d:%02d", currentHour, currentMinute)
|
|
cfg.QuietTo = fmt.Sprintf("%02d:%02d", (currentHour+1)%24, currentMinute)
|
|
m.SetConfig(cfg)
|
|
|
|
// Queue an event
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Test Event",
|
|
Body: "Should NOT be queued (digest disabled)",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// When morning digest is disabled, LOW/MEDIUM events during quiet hours
|
|
// should be sent immediately (not queued)
|
|
// Actually, looking at the code, when quiet hours are active,
|
|
// LOW/MEDIUM are still queued even if MorningDigest is false
|
|
// They just won't be sent in a digest
|
|
|
|
// The queue should have the event
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1 (still queued even with digest disabled)", digest)
|
|
}
|
|
|
|
// Manually trigger digest - should send queued events
|
|
m.sendDigest()
|
|
|
|
if len(receivedEvents) != 1 {
|
|
t.Errorf("received %d events, want 1", len(receivedEvents))
|
|
}
|
|
}
|
|
|
|
// TestHighPriorityDuringQuietHours tests HIGH priority during quiet hours.
|
|
// Note: HIGH priority bypasses batching but RESPECTS quiet hours (gets queued for digest).
|
|
func TestHighPriorityDuringQuietHours(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvent = e
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to cover current time
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "00:00",
|
|
QuietTo: "23:59",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
m.SetConfig(cfg)
|
|
|
|
// Send HIGH priority during quiet hours
|
|
event := Event{
|
|
Type: AnomalyAlert,
|
|
Priority: High,
|
|
Title: "High Priority Alert",
|
|
Body: "Respects quiet hours - queued for digest",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// HIGH respects quiet hours - should be queued for digest, NOT sent immediately
|
|
// (Only URGENT bypasses quiet hours)
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1 (HIGH respects quiet hours)", digest)
|
|
}
|
|
|
|
// Verify it was NOT sent immediately
|
|
if receivedEvent.Type != "" {
|
|
t.Errorf("HIGH event was sent immediately during quiet hours, got type=%s, want it queued", receivedEvent.Type)
|
|
}
|
|
}
|
|
|
|
// TestMediumPriorityDuringQuietHours tests MEDIUM priority during quiet hours.
|
|
func TestMediumPriorityDuringQuietHours(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "00:00",
|
|
QuietTo: "23:59",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
m.SetConfig(cfg)
|
|
|
|
// Send MEDIUM priority during quiet hours
|
|
event := Event{
|
|
Type: ZoneLeave,
|
|
Priority: Medium,
|
|
Title: "Medium Event",
|
|
Body: "Should be queued during quiet hours",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// MEDIUM should be queued for digest during quiet hours
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1 (MEDIUM queued during quiet hours)", digest)
|
|
}
|
|
}
|
|
|
|
// TestQuietHoursNotActiveOutsideWindow tests quiet hours only apply during configured window.
|
|
func TestQuietHoursNotActiveOutsideWindow(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvent = e
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to NOT include current time
|
|
now := time.Now().In(loc)
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: fmt.Sprintf("%02d:00", (now.Hour()+1)%24), // Next hour
|
|
QuietTo: fmt.Sprintf("%02d:00", (now.Hour()+2)%24),
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
m.SetConfig(cfg)
|
|
|
|
// Send LOW priority event when quiet hours are NOT active
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Daytime Activity",
|
|
Body: "Should be batched, not queued for digest",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// Outside quiet hours, LOW should be batched (not sent immediately)
|
|
if receivedEvent.Type == ZoneEnter {
|
|
t.Error("LOW event sent immediately outside quiet hours, should be batched")
|
|
}
|
|
|
|
// Should be in batch queue, not digest queue
|
|
low, _, digest := m.GetPendingCount()
|
|
if low != 1 {
|
|
t.Errorf("pendingLow = %d, want 1 (batched, not digested)", low)
|
|
}
|
|
if digest != 0 {
|
|
t.Errorf("queuedForDigest = %d, want 0 (outside quiet hours)", digest)
|
|
}
|
|
}
|
|
|
|
// TestBatchingPrioritySeparation tests LOW and MEDIUM are batched separately.
|
|
func TestBatchingPrioritySeparation(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
m, err := newTestManagerWithQuietHoursDisabled(Config{
|
|
DBPath: dbPath,
|
|
BatchWindowSec: 1,
|
|
SendCallback: func(e Event) {},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Send LOW events
|
|
for i := 0; i < 2; i++ {
|
|
m.Notify(Event{Type: ZoneEnter, Priority: Low, Title: fmt.Sprintf("L%d", i)})
|
|
}
|
|
|
|
// Send MEDIUM events
|
|
for i := 0; i < 2; i++ {
|
|
m.Notify(Event{Type: ZoneLeave, Priority: Medium, Title: fmt.Sprintf("M%d", i)})
|
|
}
|
|
|
|
low, medium, _ := m.GetPendingCount()
|
|
if low != 2 {
|
|
t.Errorf("pendingLow = %d, want 2", low)
|
|
}
|
|
if medium != 2 {
|
|
t.Errorf("pendingMedium = %d, want 2", medium)
|
|
}
|
|
|
|
// Wait for batch
|
|
time.Sleep(1500 * time.Millisecond)
|
|
|
|
// Both should be flushed
|
|
low, medium, _ = m.GetPendingCount()
|
|
if low != 0 || medium != 0 {
|
|
t.Errorf("Queues not empty after batch: low=%d, medium=%d", low, medium)
|
|
}
|
|
}
|
|
|
|
// TestQuietHoursGate_LowAt23pmQueued tests that LOW priority at 23:00 with 22:00-07:00 quiet hours is queued.
|
|
// Acceptance Criteria: LOW at 23:00 with 22:00-07:00 quiet hours -> queued
|
|
func TestQuietHoursGate_LowAt23pmQueued(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
// Use a fixed timezone for predictable testing
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
t.Error("LOW event callback should not be called during quiet hours")
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to 22:00-07:00
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "22:00",
|
|
QuietTo: "07:00",
|
|
QuietDaysBitmask: 0xFF, // All days
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Since we can't mock time, we verify the logic by setting quiet hours to cover current time
|
|
// and confirming LOW events are queued
|
|
now := time.Now().In(loc)
|
|
|
|
// If current time is between 22:00 and 07:00 (next day), quiet hours are active
|
|
// For testing purposes, we verify the quiet hours logic works correctly
|
|
currentTime := time.Date(0, 1, 1, now.Hour(), now.Minute(), 0, 0, time.UTC)
|
|
quietFrom, _ := time.Parse("15:04", "22:00")
|
|
quietTo, _ := time.Parse("15:04", "07:00")
|
|
|
|
// Check if we're in quiet hours based on the configured window
|
|
inQuietHours := false
|
|
if quietFrom.Before(quietTo) {
|
|
// Quiet hours don't cross midnight (22:00-07:00 does cross, so this won't be true)
|
|
inQuietHours = (currentTime.Equal(quietFrom) || currentTime.After(quietFrom)) && currentTime.Before(quietTo)
|
|
} else {
|
|
// Quiet hours cross midnight (like 22:00-07:00)
|
|
inQuietHours = currentTime.Equal(quietFrom) || currentTime.After(quietFrom) || currentTime.Before(quietTo)
|
|
}
|
|
|
|
// Send LOW priority event
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Late Night Activity",
|
|
Body: "Activity at 23:00 during quiet hours",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// Verify the quiet hours configuration was set correctly
|
|
retrievedCfg := m.GetConfig()
|
|
if retrievedCfg.QuietFrom != "22:00" {
|
|
t.Errorf("QuietFrom = %s, want 22:00", retrievedCfg.QuietFrom)
|
|
}
|
|
if retrievedCfg.QuietTo != "07:00" {
|
|
t.Errorf("QuietTo = %s, want 07:00", retrievedCfg.QuietTo)
|
|
}
|
|
|
|
// If current time falls within 22:00-07:00 quiet hours, verify event was queued
|
|
if inQuietHours {
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1 (LOW should be queued during quiet hours 22:00-07:00)", digest)
|
|
}
|
|
} else {
|
|
// Outside quiet hours, LOW should be batched
|
|
low, _, _ := m.GetPendingCount()
|
|
if low != 1 {
|
|
t.Errorf("pendingLow = %d, want 1 (LOW should be batched outside quiet hours)", low)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestQuietHoursGate_UrgentAt23pmDelivered tests that URGENT priority at 23:00 bypasses quiet hours.
|
|
// Acceptance Criteria: URGENT at 23:00 -> delivered (bypasses quiet hours)
|
|
func TestQuietHoursGate_UrgentAt23pmDelivered(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvent Event
|
|
callbackCalled := false
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvent = e
|
|
callbackCalled = true
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to 22:00-07:00 (so 23:00 is during quiet hours)
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "22:00",
|
|
QuietTo: "07:00",
|
|
QuietDaysBitmask: 0xFF, // All days
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Verify the configuration
|
|
retrievedCfg := m.GetConfig()
|
|
if retrievedCfg.QuietFrom != "22:00" {
|
|
t.Errorf("QuietFrom = %s, want 22:00", retrievedCfg.QuietFrom)
|
|
}
|
|
if retrievedCfg.QuietTo != "07:00" {
|
|
t.Errorf("QuietTo = %s, want 07:00", retrievedCfg.QuietTo)
|
|
}
|
|
|
|
// Send URGENT priority event (like fall detection)
|
|
urgentEvent := Event{
|
|
Type: FallDetected,
|
|
Priority: Urgent,
|
|
Title: "FALL DETECTED at 23:00",
|
|
Body: "Immediate action required - bypasses quiet hours gate",
|
|
}
|
|
|
|
err = m.Notify(urgentEvent)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// URGENT events should ALWAYS be delivered immediately, bypassing quiet hours
|
|
if !callbackCalled {
|
|
t.Error("URGENT event callback was not called - URGENT should bypass quiet hours gate")
|
|
}
|
|
|
|
if receivedEvent.Type != FallDetected {
|
|
t.Errorf("Received type = %s, want FallDetected", receivedEvent.Type)
|
|
}
|
|
|
|
if receivedEvent.Priority != Urgent {
|
|
t.Errorf("Received priority = %d, want Urgent", receivedEvent.Priority)
|
|
}
|
|
|
|
// URGENT should not be in any queue (no batching, no digest queuing)
|
|
low, medium, digest := m.GetPendingCount()
|
|
if low != 0 {
|
|
t.Errorf("pendingLow = %d, want 0 (URGENT bypasses batching)", low)
|
|
}
|
|
if medium != 0 {
|
|
t.Errorf("pendingMedium = %d, want 0 (URGENT bypasses batching)", medium)
|
|
}
|
|
if digest != 0 {
|
|
t.Errorf("queuedForDigest = %d, want 0 (URGENT bypasses quiet hours)", digest)
|
|
}
|
|
}
|
|
|
|
// TestQuietHoursGate_MediumAt23pmQueued tests that MEDIUM priority at 23:00 with 22:00-07:00 quiet hours is queued.
|
|
func TestQuietHoursGate_MediumAt23pmQueued(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
t.Error("MEDIUM event callback should not be called during quiet hours")
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to 22:00-07:00
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "22:00",
|
|
QuietTo: "07:00",
|
|
QuietDaysBitmask: 0xFF, // All days
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Set quiet hours to cover current time for testing
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg.QuietFrom = fmt.Sprintf("%02d:%02d", currentHour, currentMinute)
|
|
cfg.QuietTo = fmt.Sprintf("%02d:%02d", (currentHour+2)%24, currentMinute)
|
|
m.SetConfig(cfg)
|
|
|
|
// Send MEDIUM priority event
|
|
event := Event{
|
|
Type: AnomalyAlert,
|
|
Priority: Medium,
|
|
Title: "Anomaly at 23:00",
|
|
Body: "Should be queued during quiet hours",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// MEDIUM should be queued for digest during quiet hours
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1 (MEDIUM should be queued during quiet hours)", digest)
|
|
}
|
|
}
|
|
|
|
// TestQuietHoursGate_HighAt23pmDelivered tests that HIGH priority at 23:00 is delivered (bypasses batching but not quiet hours).
|
|
func TestQuietHoursGate_HighAt23pmDelivered(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvent = e
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to cover current time (simulating 23:00 during 22:00-07:00 window)
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: fmt.Sprintf("%02d:%02d", currentHour, currentMinute),
|
|
QuietTo: fmt.Sprintf("%02d:%02d", (currentHour+2)%24, currentMinute),
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Send HIGH priority event during quiet hours
|
|
event := Event{
|
|
Type: NodeOffline,
|
|
Priority: High,
|
|
Title: "Node Offline at 23:00",
|
|
Body: "HIGH priority bypasses batching but respects quiet hours",
|
|
}
|
|
|
|
err = m.Notify(event)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// HIGH bypasses batching but respects quiet hours
|
|
// During quiet hours, HIGH is queued for digest
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1 (HIGH is queued during quiet hours)", digest)
|
|
}
|
|
|
|
// Now test HIGH outside quiet hours - should be sent immediately
|
|
cfg.QuietFrom = fmt.Sprintf("%02d:00", (now.Hour()+1)%24) // Next hour
|
|
cfg.QuietTo = fmt.Sprintf("%02d:00", (now.Hour()+2)%24)
|
|
m.SetConfig(cfg)
|
|
|
|
// Reset received event
|
|
receivedEvent = Event{}
|
|
|
|
event2 := Event{
|
|
Type: NodeOffline,
|
|
Priority: High,
|
|
Title: "Node Offline - Outside Quiet Hours",
|
|
Body: "HIGH priority sent immediately outside quiet hours",
|
|
}
|
|
|
|
err = m.Notify(event2)
|
|
if err != nil {
|
|
t.Fatalf("Notify() error = %v", err)
|
|
}
|
|
|
|
// HIGH should be sent immediately outside quiet hours
|
|
if receivedEvent.Type != NodeOffline {
|
|
t.Errorf("Received type = %s, want NodeOffline", receivedEvent.Type)
|
|
}
|
|
}
|
|
|
|
// TestMorningDigestOncePerDay tests that digest is only sent once per day.
|
|
func TestMorningDigestOncePerDay(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedCount int
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedCount++
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Enable morning digest
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "22:00",
|
|
QuietTo: "07:00",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Queue some events by setting quiet hours to cover current time
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg.QuietFrom = fmt.Sprintf("%02d:%02d", currentHour, currentMinute)
|
|
cfg.QuietTo = fmt.Sprintf("%02d:%02d", (currentHour+2)%24, currentMinute)
|
|
m.SetConfig(cfg)
|
|
|
|
// Queue multiple events
|
|
for i := 0; i < 3; i++ {
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: fmt.Sprintf("Event %d", i),
|
|
Body: "Test message",
|
|
}
|
|
m.Notify(event)
|
|
}
|
|
|
|
// Send digest
|
|
m.sendDigest()
|
|
|
|
if receivedCount != 1 {
|
|
t.Errorf("received %d events after first digest, want 1", receivedCount)
|
|
}
|
|
|
|
// Try to send digest again - should not send (already sent today)
|
|
m.sendDigest()
|
|
|
|
if receivedCount != 1 {
|
|
t.Errorf("received %d events after second digest attempt, want 1 (digest should only be sent once per day)", receivedCount)
|
|
}
|
|
}
|
|
|
|
// TestMorningDigestEmptyNotSent tests that empty digest is not sent.
|
|
func TestMorningDigestEmptyNotSent(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
var receivedCount int
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
SendCallback: func(e Event) {
|
|
receivedCount++
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Enable morning digest
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "22:00",
|
|
QuietTo: "07:00",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Send digest with no queued events
|
|
m.sendDigest()
|
|
|
|
// Should not have received anything
|
|
if receivedCount != 0 {
|
|
t.Errorf("received %d events, want 0 (empty digest should not be sent)", receivedCount)
|
|
}
|
|
}
|
|
|
|
// TestIsQuietHoursEnd tests the isQuietHoursEnd function.
|
|
func TestIsQuietHoursEnd(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Test with morning digest disabled
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: "22:00",
|
|
QuietTo: "07:00",
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: false, // Disabled
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// When morning digest is disabled, isQuietHoursEnd should return false
|
|
// We can't test the actual time-based behavior deterministically without mocking time,
|
|
// but we can verify that when disabled, it returns false
|
|
// The implementation checks cfg.MorningDigest first
|
|
|
|
// Enable morning digest
|
|
cfg.MorningDigest = true
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Verify the quiet hours configuration
|
|
retrievedCfg := m.GetConfig()
|
|
if !retrievedCfg.MorningDigest {
|
|
t.Error("MorningDigest should be true")
|
|
}
|
|
if retrievedCfg.QuietTo != "07:00" {
|
|
t.Errorf("QuietTo = %s, want 07:00", retrievedCfg.QuietTo)
|
|
}
|
|
}
|
|
|
|
// TestMorningDigestIncludesAllEvents tests that digest includes all queued events.
|
|
func TestMorningDigestIncludesAllEvents(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvent = e
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to cover current time FIRST, before any other config
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: fmt.Sprintf("%02d:%02d", currentHour, currentMinute),
|
|
QuietTo: fmt.Sprintf("%02d:%02d", (currentHour+2)%24, currentMinute),
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Queue events with different types
|
|
events := []Event{
|
|
{Type: ZoneEnter, Priority: Low, Title: "Zone Enter", Body: "Entered kitchen"},
|
|
{Type: ZoneLeave, Priority: Low, Title: "Zone Leave", Body: "Left hallway"},
|
|
{Type: AnomalyAlert, Priority: Medium, Title: "Anomaly", Body: "Unusual activity"},
|
|
}
|
|
|
|
for _, e := range events {
|
|
m.Notify(e)
|
|
}
|
|
|
|
// Verify all events are queued
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 3 {
|
|
t.Errorf("queuedForDigest = %d, want 3", digest)
|
|
}
|
|
|
|
// Send digest
|
|
m.sendDigest()
|
|
|
|
// Verify digest was sent
|
|
if receivedEvent.Data["is_digest"] != true {
|
|
t.Error("Received event is not marked as digest")
|
|
}
|
|
|
|
// Verify event count
|
|
eventCount, ok := receivedEvent.Data["event_count"].(int)
|
|
if !ok || eventCount != 3 {
|
|
t.Errorf("event_count = %v, want 3", receivedEvent.Data["event_count"])
|
|
}
|
|
|
|
// Verify type counts include all event types
|
|
typeCounts, ok := receivedEvent.Data["type_counts"].(map[EventType]int)
|
|
if !ok {
|
|
t.Fatal("type_counts not found or wrong type")
|
|
}
|
|
|
|
if typeCounts[ZoneEnter] != 1 {
|
|
t.Errorf("ZoneEnter count = %d, want 1", typeCounts[ZoneEnter])
|
|
}
|
|
if typeCounts[ZoneLeave] != 1 {
|
|
t.Errorf("ZoneLeave count = %d, want 1", typeCounts[ZoneLeave])
|
|
}
|
|
if typeCounts[AnomalyAlert] != 1 {
|
|
t.Errorf("AnomalyAlert count = %d, want 1", typeCounts[AnomalyAlert])
|
|
}
|
|
}
|
|
|
|
// TestMorningDigestClearedAfterSend tests that digest queue is cleared after sending.
|
|
func TestMorningDigestClearedAfterSend(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to cover current time FIRST
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: fmt.Sprintf("%02d:%02d", currentHour, currentMinute),
|
|
QuietTo: fmt.Sprintf("%02d:%02d", (currentHour+2)%24, currentMinute),
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Queue events
|
|
for i := 0; i < 5; i++ {
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: fmt.Sprintf("Event %d", i),
|
|
Body: "Test",
|
|
}
|
|
m.Notify(event)
|
|
}
|
|
|
|
// Verify events are queued
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 5 {
|
|
t.Errorf("queuedForDigest = %d, want 5", digest)
|
|
}
|
|
|
|
// Send digest
|
|
m.sendDigest()
|
|
|
|
// Verify queue is cleared
|
|
_, _, digest = m.GetPendingCount()
|
|
if digest != 0 {
|
|
t.Errorf("queuedForDigest = %d after sendDigest, want 0", digest)
|
|
}
|
|
|
|
// Verify that calling sendDigest again on the same day does nothing (already sent today)
|
|
// Queue another event
|
|
event := Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "New Event",
|
|
Body: "After digest",
|
|
}
|
|
m.Notify(event)
|
|
|
|
// Queue should have the new event
|
|
_, _, digest = m.GetPendingCount()
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d, want 1", digest)
|
|
}
|
|
|
|
// Try to send digest again - should NOT send because digest was already sent today
|
|
// The digestSentDate check prevents duplicate digests on the same day
|
|
m.sendDigest()
|
|
|
|
// Queue should still have the event (not sent)
|
|
_, _, digest = m.GetPendingCount()
|
|
if digest != 1 {
|
|
t.Errorf("queuedForDigest = %d after second sendDigest (same day), want 1 (should not send again)", digest)
|
|
}
|
|
}
|
|
|
|
// TestMorningDigestWithMixedPriorities tests that digest includes LOW and MEDIUM events.
|
|
func TestMorningDigestWithMixedPriorities(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvent = e
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to cover current time FIRST
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: fmt.Sprintf("%02d:%02d", currentHour, currentMinute),
|
|
QuietTo: fmt.Sprintf("%02d:%02d", (currentHour+2)%24, currentMinute),
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Queue mixed priority events (LOW and MEDIUM both go to digest during quiet hours)
|
|
m.Notify(Event{Type: ZoneEnter, Priority: Low, Title: "Low Event"})
|
|
m.Notify(Event{Type: ZoneLeave, Priority: Medium, Title: "Medium Event"})
|
|
m.Notify(Event{Type: ZoneVacant, Priority: Low, Title: "Another Low"})
|
|
|
|
// Verify all are in digest queue
|
|
_, _, digest := m.GetPendingCount()
|
|
if digest != 3 {
|
|
t.Errorf("queuedForDigest = %d, want 3 (LOW and MEDIUM both queued during quiet hours)", digest)
|
|
}
|
|
|
|
// Send digest
|
|
m.sendDigest()
|
|
|
|
// Verify digest includes all events
|
|
eventCount, ok := receivedEvent.Data["event_count"].(int)
|
|
if !ok || eventCount != 3 {
|
|
t.Errorf("event_count = %v, want 3", receivedEvent.Data["event_count"])
|
|
}
|
|
}
|
|
|
|
// TestMorningDigestTitleFormat tests the digest notification title.
|
|
func TestMorningDigestTitleFormat(t *testing.T) {
|
|
dbPath := t.TempDir() + "/test.db"
|
|
|
|
loc, err := time.LoadLocation("America/New_York")
|
|
if err != nil {
|
|
t.Skip("Skipping test: cannot load timezone")
|
|
}
|
|
|
|
var receivedEvent Event
|
|
m, err := New(Config{
|
|
DBPath: dbPath,
|
|
Location: loc,
|
|
SendCallback: func(e Event) {
|
|
receivedEvent = e
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("New() error = %v", err)
|
|
}
|
|
defer m.Close()
|
|
|
|
// Set quiet hours to cover current time FIRST
|
|
now := time.Now().In(loc)
|
|
currentHour := now.Hour()
|
|
currentMinute := now.Minute()
|
|
|
|
cfg := NotificationConfig{
|
|
Channel: "default",
|
|
QuietFrom: fmt.Sprintf("%02d:%02d", currentHour, currentMinute),
|
|
QuietTo: fmt.Sprintf("%02d:%02d", (currentHour+2)%24, currentMinute),
|
|
QuietDaysBitmask: 0xFF,
|
|
MorningDigest: true,
|
|
}
|
|
|
|
err = m.SetConfig(cfg)
|
|
if err != nil {
|
|
t.Fatalf("SetConfig() error = %v", err)
|
|
}
|
|
|
|
// Queue a single event
|
|
m.Notify(Event{
|
|
Type: ZoneEnter,
|
|
Priority: Low,
|
|
Title: "Test Event",
|
|
Body: "Test",
|
|
})
|
|
|
|
// Send digest
|
|
m.sendDigest()
|
|
|
|
// Verify title format
|
|
expectedTitle := "Morning Digest: 1 event(s) while you slept"
|
|
if receivedEvent.Title != expectedTitle {
|
|
t.Errorf("Title = %s, want %s", receivedEvent.Title, expectedTitle)
|
|
}
|
|
|
|
// Verify it's marked as digest
|
|
if receivedEvent.Data["is_digest"] != true {
|
|
t.Error("Event should be marked as digest")
|
|
}
|
|
|
|
// Verify body contains event details
|
|
if !contains(receivedEvent.Body, "zone_enter") {
|
|
t.Errorf("Body should contain event type, got: %s", receivedEvent.Body)
|
|
}
|
|
}
|
|
|
|
// contains is a helper function to check if a string contains a substring.
|
|
func contains(s, substr string) bool {
|
|
return len(s) >= len(substr) && (s == substr || len(s) > len(substr) && indexOf(s, substr) >= 0)
|
|
}
|
|
|
|
// indexOf finds the index of substr in s, or -1 if not found.
|
|
func indexOf(s, substr string) int {
|
|
for i := 0; i <= len(s)-len(substr); i++ {
|
|
if s[i:i+len(substr)] == substr {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|