max / goingson

5.0 KB · 169 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(
27	user_id,
28	NewBackupSettings {
29	auto_backup_enabled: true,
30	backup_frequency_minutes: 30,
31	max_backups_to_keep: 5,
32	},
33	)
34	.await
35	.expect("upsert insert");
36
37	assert!(created.auto_backup_enabled);
38	assert_eq!(created.backup_frequency_minutes, 30);
39	assert_eq!(created.max_backups_to_keep, 5);
40	assert!(
41	created.last_backup_at.is_none(),
42	"a new row has no backup timestamp yet"
43	);
44
45	let fetched = repo
46	.get(user_id)
47	.await
48	.expect("get")
49	.expect("row should exist after upsert");
50	assert_eq!(
51	fetched.id, created.id,
52	"get must return the same persisted row"
53	);
54	assert!(fetched.auto_backup_enabled);
55	assert_eq!(fetched.backup_frequency_minutes, 30);
56	assert_eq!(fetched.max_backups_to_keep, 5);
57	}
58
59	#[tokio::test]
60	async fn test_upsert_updates_existing_row_in_place() {
61	let pool = common::setup_test_db().await;
62	let user_id = common::create_test_user(&pool).await;
63	let repo = SqliteBackupSettingsRepository::new(pool);
64
65	let first = repo
66	.upsert(
67	user_id,
68	NewBackupSettings {
69	auto_backup_enabled: true,
70	backup_frequency_minutes: 15,
71	max_backups_to_keep: 1,
72	},
73	)
74	.await
75	.expect("first upsert");
76
77	let second = repo
78	.upsert(
79	user_id,
80	NewBackupSettings {
81	auto_backup_enabled: false,
82	backup_frequency_minutes: 120,
83	max_backups_to_keep: 10,
84	},
85	)
86	.await
87	.expect("second upsert");
88
89	assert_eq!(
90	second.id, first.id,
91	"upsert must update in place, not create a second row"
92	);
93	assert!(!second.auto_backup_enabled);
94	assert_eq!(second.backup_frequency_minutes, 120);
95	assert_eq!(second.max_backups_to_keep, 10);
96
97	let fetched = repo.get(user_id).await.expect("get").expect("row exists");
98	assert!(
99	!fetched.auto_backup_enabled,
100	"the updated values must persist"
101	);
102	assert_eq!(fetched.backup_frequency_minutes, 120);
103	assert_eq!(fetched.max_backups_to_keep, 10);
104	}
105
106	#[tokio::test]
107	async fn test_update_last_backup_at_reflected_in_get() {
108	let pool = common::setup_test_db().await;
109	let user_id = common::create_test_user(&pool).await;
110	let repo = SqliteBackupSettingsRepository::new(pool);
111
112	repo.upsert(
113	user_id,
114	NewBackupSettings {
115	auto_backup_enabled: true,
116	backup_frequency_minutes: 15,
117	max_backups_to_keep: 1,
118	},
119	)
120	.await
121	.expect("upsert");
122
123	let ts = Utc::now() - Duration::minutes(3);
124	repo.update_last_backup_at(user_id, ts)
125	.await
126	.expect("update_last_backup_at");
127
128	let fetched = repo.get(user_id).await.expect("get").expect("row exists");
129	let stored = fetched.last_backup_at.expect("last_backup_at must be set");
130	assert!(
131	(stored - ts).num_seconds().abs() <= 1,
132	"stored backup time must match the value written (within second precision)"
133	);
134	}
135
136	#[tokio::test]
137	async fn test_update_last_backup_at_creates_defaults_when_absent() {
138	let pool = common::setup_test_db().await;
139	let user_id = common::create_test_user(&pool).await;
140	let repo = SqliteBackupSettingsRepository::new(pool);
141
142	// No prior upsert: the update must lazily create default settings.
143	assert!(repo.get(user_id).await.expect("get").is_none());
144
145	let ts = Utc::now();
146	repo.update_last_backup_at(user_id, ts)
147	.await
148	.expect("update_last_backup_at");
149
150	let fetched = repo
151	.get(user_id)
152	.await
153	.expect("get")
154	.expect("defaults should have been created");
155	assert!(
156	fetched.auto_backup_enabled,
157	"lazy default enables auto backup"
158	);
159	assert_eq!(
160	fetched.backup_frequency_minutes, 15,
161	"lazy default frequency"
162	);
163	assert_eq!(fetched.max_backups_to_keep, 1, "lazy default retention");
164	assert!(
165	fetched.last_backup_at.is_some(),
166	"the backup timestamp must be recorded"
167	);
168	}
169