Skip to main content

max / goingson

7.9 KB · 239 lines History Blame Raw
1 //! Integration tests for SqliteSavedViewRepository.
2
3 mod common;
4
5 use goingson_core::{
6 NewSavedView, Priority, ProjectId, SavedViewRepository, SortDirection, SortField, TaskStatus,
7 ViewFilters, ViewType,
8 };
9 use goingson_db_sqlite::SqliteSavedViewRepository;
10
11 #[tokio::test]
12 async fn test_create_and_get_saved_view() {
13 let pool = common::setup_test_db().await;
14 let user_id = common::create_test_user(&pool).await;
15 let repo = SqliteSavedViewRepository::new(pool);
16
17 let filters = ViewFilters {
18 status: Some(vec![TaskStatus::Pending]),
19 priority: Some(vec![Priority::High]),
20 ..Default::default()
21 };
22
23 let new_view = NewSavedView {
24 name: "High Priority Pending".to_string(),
25 view_type: ViewType::Tasks,
26 filters,
27 sort_by: Some(SortField::Urgency),
28 sort_order: Some(SortDirection::Desc),
29 is_pinned: Some(true),
30 };
31
32 let created = repo.create(user_id, new_view).await.expect("Failed to create view");
33 assert_eq!(created.name, "High Priority Pending");
34 assert_eq!(created.view_type, ViewType::Tasks);
35 assert!(created.is_pinned);
36
37 let fetched = repo.get_by_id(created.id, user_id).await.expect("Failed to get view");
38 assert!(fetched.is_some());
39 let fetched = fetched.unwrap();
40 assert_eq!(fetched.id, created.id);
41 assert_eq!(fetched.filters.status, Some(vec![TaskStatus::Pending]));
42 }
43
44 #[tokio::test]
45 async fn test_list_pinned_views() {
46 let pool = common::setup_test_db().await;
47 let user_id = common::create_test_user(&pool).await;
48 let repo = SqliteSavedViewRepository::new(pool);
49
50 // Create pinned view
51 let pinned = NewSavedView {
52 name: "Pinned View".to_string(),
53 view_type: ViewType::Tasks,
54 filters: ViewFilters::default(),
55 sort_by: None,
56 sort_order: Some(SortDirection::Asc),
57 is_pinned: Some(true),
58 };
59 repo.create(user_id, pinned).await.expect("Failed to create");
60
61 // Create unpinned view
62 let unpinned = NewSavedView {
63 name: "Unpinned View".to_string(),
64 view_type: ViewType::Tasks,
65 filters: ViewFilters::default(),
66 sort_by: None,
67 sort_order: Some(SortDirection::Asc),
68 is_pinned: Some(false),
69 };
70 repo.create(user_id, unpinned).await.expect("Failed to create");
71
72 let pinned_views = repo.list_pinned(user_id).await.expect("Failed to list pinned");
73 assert_eq!(pinned_views.len(), 1);
74 assert_eq!(pinned_views[0].name, "Pinned View");
75
76 let all_views = repo.list_all(user_id).await.expect("Failed to list all");
77 assert_eq!(all_views.len(), 2);
78 }
79
80 #[tokio::test]
81 async fn test_toggle_pinned() {
82 let pool = common::setup_test_db().await;
83 let user_id = common::create_test_user(&pool).await;
84 let repo = SqliteSavedViewRepository::new(pool);
85
86 let new_view = NewSavedView {
87 name: "Toggle Test".to_string(),
88 view_type: ViewType::Emails,
89 filters: ViewFilters::default(),
90 sort_by: None,
91 sort_order: Some(SortDirection::Desc),
92 is_pinned: Some(false),
93 };
94
95 let created = repo.create(user_id, new_view).await.expect("Failed to create");
96 assert!(!created.is_pinned);
97
98 // Toggle to pinned
99 let toggled = repo.toggle_pinned(created.id, user_id).await.expect("Failed to toggle");
100 assert!(toggled.is_some());
101 assert!(toggled.as_ref().unwrap().is_pinned);
102
103 // Toggle back to unpinned
104 let toggled = repo.toggle_pinned(created.id, user_id).await.expect("Failed to toggle");
105 assert!(toggled.is_some());
106 assert!(!toggled.unwrap().is_pinned);
107 }
108
109 #[tokio::test]
110 async fn test_update_saved_view() {
111 let pool = common::setup_test_db().await;
112 let user_id = common::create_test_user(&pool).await;
113 let repo = SqliteSavedViewRepository::new(pool);
114
115 let new_view = NewSavedView {
116 name: "Original Name".to_string(),
117 view_type: ViewType::Tasks,
118 filters: ViewFilters::default(),
119 sort_by: None,
120 sort_order: Some(SortDirection::Asc),
121 is_pinned: Some(false),
122 };
123
124 let created = repo.create(user_id, new_view).await.expect("Failed to create");
125
126 // Update the view
127 let updated_filters = ViewFilters {
128 status: Some(vec![TaskStatus::Completed]),
129 ..Default::default()
130 };
131
132 let update = NewSavedView {
133 name: "Updated Name".to_string(),
134 view_type: ViewType::Tasks,
135 filters: updated_filters,
136 sort_by: Some(SortField::CreatedAt),
137 sort_order: Some(SortDirection::Desc),
138 is_pinned: Some(true),
139 };
140
141 let updated = repo.update(created.id, user_id, update).await.expect("Failed to update");
142 assert!(updated.is_some());
143 let updated = updated.unwrap();
144 assert_eq!(updated.name, "Updated Name");
145 assert!(updated.is_pinned);
146 assert_eq!(updated.sort_order, SortDirection::Desc);
147 }
148
149 #[tokio::test]
150 async fn test_delete_saved_view() {
151 let pool = common::setup_test_db().await;
152 let user_id = common::create_test_user(&pool).await;
153 let repo = SqliteSavedViewRepository::new(pool);
154
155 let new_view = NewSavedView {
156 name: "To Delete".to_string(),
157 view_type: ViewType::Events,
158 filters: ViewFilters::default(),
159 sort_by: None,
160 sort_order: Some(SortDirection::Asc),
161 is_pinned: Some(true),
162 };
163
164 let created = repo.create(user_id, new_view).await.expect("Failed to create");
165
166 let deleted = repo.delete(created.id, user_id).await.expect("Failed to delete");
167 assert!(deleted);
168
169 let fetched = repo.get_by_id(created.id, user_id).await.expect("Failed to get");
170 assert!(fetched.is_none());
171 }
172
173 #[tokio::test]
174 async fn test_view_filters_serialization() {
175 let pool = common::setup_test_db().await;
176 let user_id = common::create_test_user(&pool).await;
177 let repo = SqliteSavedViewRepository::new(pool);
178
179 let filters = ViewFilters {
180 status: Some(vec![TaskStatus::Pending, TaskStatus::Started]),
181 priority: Some(vec![Priority::High, Priority::Medium]),
182 project_id: Some(ProjectId::new()),
183 is_snoozed: Some(true),
184 is_waiting: Some(false),
185 ..Default::default()
186 };
187
188 let new_view = NewSavedView {
189 name: "Complex Filters".to_string(),
190 view_type: ViewType::Tasks,
191 filters: filters.clone(),
192 sort_by: Some(SortField::Due),
193 sort_order: Some(SortDirection::Asc),
194 is_pinned: Some(true),
195 };
196
197 let created = repo.create(user_id, new_view).await.expect("Failed to create");
198
199 let fetched = repo.get_by_id(created.id, user_id).await.expect("Failed to get");
200 assert!(fetched.is_some());
201 let fetched = fetched.unwrap();
202
203 // Verify all filter fields round-trip correctly
204 assert_eq!(fetched.filters.status, filters.status);
205 assert_eq!(fetched.filters.priority, filters.priority);
206 assert_eq!(fetched.filters.project_id, filters.project_id);
207 assert_eq!(fetched.filters.is_snoozed, filters.is_snoozed);
208 assert_eq!(fetched.filters.is_waiting, filters.is_waiting);
209 }
210
211 #[tokio::test]
212 async fn test_position_ordering() {
213 let pool = common::setup_test_db().await;
214 let user_id = common::create_test_user(&pool).await;
215 let repo = SqliteSavedViewRepository::new(pool);
216
217 // Create multiple pinned views
218 for i in 1..=3 {
219 let view = NewSavedView {
220 name: format!("View {}", i),
221 view_type: ViewType::Tasks,
222 filters: ViewFilters::default(),
223 sort_by: None,
224 sort_order: Some(SortDirection::Asc),
225 is_pinned: Some(true),
226 };
227 repo.create(user_id, view).await.expect("Failed to create");
228 }
229
230 let views = repo.list_pinned(user_id).await.expect("Failed to list");
231 assert_eq!(views.len(), 3);
232
233 // Views should maintain consistent ordering
234 // Position is assigned on creation (implementation dependent)
235 for (i, view) in views.iter().enumerate() {
236 assert_eq!(view.name, format!("View {}", i + 1));
237 }
238 }
239