Skip to main content

max / goingson

4.5 KB · 121 lines History Blame Raw
1 //! Integration tests for SqliteBackupSettingsRepository.
2
3 mod common;
4
5 use chrono::{Duration, Utc};
6 use goingson_core::{BackupSettingsRepository, NewBackupSettings};
7 use goingson_db_sqlite::SqliteBackupSettingsRepository;
8
9 #[tokio::test]
10 async fn test_get_returns_none_when_absent() {
11 let pool = common::setup_test_db().await;
12 let user_id = common::create_test_user(&pool).await;
13 let repo = SqliteBackupSettingsRepository::new(pool);
14
15 let settings = repo.get(user_id).await.expect("get");
16 assert!(settings.is_none(), "no row should exist for a fresh user");
17 }
18
19 #[tokio::test]
20 async fn test_upsert_inserts_then_get_round_trips() {
21 let pool = common::setup_test_db().await;
22 let user_id = common::create_test_user(&pool).await;
23 let repo = SqliteBackupSettingsRepository::new(pool);
24
25 let created = repo
26 .upsert(user_id, NewBackupSettings {
27 auto_backup_enabled: true,
28 backup_frequency_minutes: 30,
29 max_backups_to_keep: 5,
30 })
31 .await
32 .expect("upsert insert");
33
34 assert!(created.auto_backup_enabled);
35 assert_eq!(created.backup_frequency_minutes, 30);
36 assert_eq!(created.max_backups_to_keep, 5);
37 assert!(created.last_backup_at.is_none(), "a new row has no backup timestamp yet");
38
39 let fetched = repo.get(user_id).await.expect("get").expect("row should exist after upsert");
40 assert_eq!(fetched.id, created.id, "get must return the same persisted row");
41 assert!(fetched.auto_backup_enabled);
42 assert_eq!(fetched.backup_frequency_minutes, 30);
43 assert_eq!(fetched.max_backups_to_keep, 5);
44 }
45
46 #[tokio::test]
47 async fn test_upsert_updates_existing_row_in_place() {
48 let pool = common::setup_test_db().await;
49 let user_id = common::create_test_user(&pool).await;
50 let repo = SqliteBackupSettingsRepository::new(pool);
51
52 let first = repo
53 .upsert(user_id, NewBackupSettings {
54 auto_backup_enabled: true,
55 backup_frequency_minutes: 15,
56 max_backups_to_keep: 1,
57 })
58 .await
59 .expect("first upsert");
60
61 let second = repo
62 .upsert(user_id, NewBackupSettings {
63 auto_backup_enabled: false,
64 backup_frequency_minutes: 120,
65 max_backups_to_keep: 10,
66 })
67 .await
68 .expect("second upsert");
69
70 assert_eq!(second.id, first.id, "upsert must update in place, not create a second row");
71 assert!(!second.auto_backup_enabled);
72 assert_eq!(second.backup_frequency_minutes, 120);
73 assert_eq!(second.max_backups_to_keep, 10);
74
75 let fetched = repo.get(user_id).await.expect("get").expect("row exists");
76 assert!(!fetched.auto_backup_enabled, "the updated values must persist");
77 assert_eq!(fetched.backup_frequency_minutes, 120);
78 assert_eq!(fetched.max_backups_to_keep, 10);
79 }
80
81 #[tokio::test]
82 async fn test_update_last_backup_at_reflected_in_get() {
83 let pool = common::setup_test_db().await;
84 let user_id = common::create_test_user(&pool).await;
85 let repo = SqliteBackupSettingsRepository::new(pool);
86
87 repo.upsert(user_id, NewBackupSettings {
88 auto_backup_enabled: true,
89 backup_frequency_minutes: 15,
90 max_backups_to_keep: 1,
91 })
92 .await
93 .expect("upsert");
94
95 let ts = Utc::now() - Duration::minutes(3);
96 repo.update_last_backup_at(user_id, ts).await.expect("update_last_backup_at");
97
98 let fetched = repo.get(user_id).await.expect("get").expect("row exists");
99 let stored = fetched.last_backup_at.expect("last_backup_at must be set");
100 assert!((stored - ts).num_seconds().abs() <= 1, "stored backup time must match the value written (within second precision)");
101 }
102
103 #[tokio::test]
104 async fn test_update_last_backup_at_creates_defaults_when_absent() {
105 let pool = common::setup_test_db().await;
106 let user_id = common::create_test_user(&pool).await;
107 let repo = SqliteBackupSettingsRepository::new(pool);
108
109 // No prior upsert: the update must lazily create default settings.
110 assert!(repo.get(user_id).await.expect("get").is_none());
111
112 let ts = Utc::now();
113 repo.update_last_backup_at(user_id, ts).await.expect("update_last_backup_at");
114
115 let fetched = repo.get(user_id).await.expect("get").expect("defaults should have been created");
116 assert!(fetched.auto_backup_enabled, "lazy default enables auto backup");
117 assert_eq!(fetched.backup_frequency_minutes, 15, "lazy default frequency");
118 assert_eq!(fetched.max_backups_to_keep, 1, "lazy default retention");
119 assert!(fetched.last_backup_at.is_some(), "the backup timestamp must be recorded");
120 }
121