Skip to main content

max / goingson

4.8 KB · 140 lines History Blame Raw
1 //! Integration tests for SqliteProjectRepository.
2
3 mod common;
4
5 use goingson_core::{NewProject, ProjectRepository, ProjectStatus, ProjectType, UpdateProject};
6 use goingson_db_sqlite::SqliteProjectRepository;
7
8 #[tokio::test]
9 async fn test_create_and_get_project() {
10 let pool = common::setup_test_db().await;
11 let user_id = common::create_test_user(&pool).await;
12 let repo = SqliteProjectRepository::new(pool);
13
14 let new_project = NewProject {
15 name: "Test Project".to_string(),
16 description: "A test project".to_string(),
17 project_type: ProjectType::SideProject,
18 status: ProjectStatus::Active,
19 };
20
21 let created = repo.create(user_id, new_project).await.expect("Failed to create project");
22 assert_eq!(created.name, "Test Project");
23 assert_eq!(created.description, "A test project");
24 assert_eq!(created.project_type, ProjectType::SideProject);
25 assert_eq!(created.status, ProjectStatus::Active);
26
27 let fetched = repo.get_by_id(created.id, user_id).await.expect("Failed to get project");
28 assert!(fetched.is_some());
29 let fetched = fetched.unwrap();
30 assert_eq!(fetched.id, created.id);
31 assert_eq!(fetched.name, "Test Project");
32 }
33
34 #[tokio::test]
35 async fn test_list_projects() {
36 let pool = common::setup_test_db().await;
37 let user_id = common::create_test_user(&pool).await;
38 let repo = SqliteProjectRepository::new(pool);
39
40 // Create multiple projects
41 for i in 1..=3 {
42 let new_project = NewProject {
43 name: format!("Project {}", i),
44 description: format!("Description {}", i),
45 project_type: ProjectType::Job,
46 status: ProjectStatus::Active,
47 };
48 repo.create(user_id, new_project).await.expect("Failed to create project");
49 }
50
51 let projects = repo.list_all(user_id).await.expect("Failed to list projects");
52 assert_eq!(projects.len(), 3);
53 }
54
55 #[tokio::test]
56 async fn test_update_project() {
57 let pool = common::setup_test_db().await;
58 let user_id = common::create_test_user(&pool).await;
59 let repo = SqliteProjectRepository::new(pool);
60
61 let new_project = NewProject {
62 name: "Original Name".to_string(),
63 description: "Original description".to_string(),
64 project_type: ProjectType::Job,
65 status: ProjectStatus::Active,
66 };
67
68 let created = repo.create(user_id, new_project).await.expect("Failed to create project");
69
70 let update = UpdateProject {
71 name: "Updated Name".to_string(),
72 description: "Updated description".to_string(),
73 project_type: ProjectType::Company,
74 status: ProjectStatus::OnHold,
75 };
76 let updated = repo.update(
77 created.id,
78 user_id,
79 update,
80 ).await.expect("Failed to update project");
81
82 assert!(updated.is_some());
83 let updated = updated.unwrap();
84 assert_eq!(updated.name, "Updated Name");
85 assert_eq!(updated.description, "Updated description");
86 assert_eq!(updated.project_type, ProjectType::Company);
87 assert_eq!(updated.status, ProjectStatus::OnHold);
88 }
89
90 #[tokio::test]
91 async fn test_delete_project() {
92 let pool = common::setup_test_db().await;
93 let user_id = common::create_test_user(&pool).await;
94 let repo = SqliteProjectRepository::new(pool);
95
96 let new_project = NewProject {
97 name: "To Delete".to_string(),
98 description: "Will be deleted".to_string(),
99 project_type: ProjectType::Other,
100 status: ProjectStatus::Active,
101 };
102
103 let created = repo.create(user_id, new_project).await.expect("Failed to create project");
104
105 let deleted = repo.delete(created.id, user_id).await.expect("Failed to delete project");
106 assert!(deleted);
107
108 let fetched = repo.get_by_id(created.id, user_id).await.expect("Failed to get project");
109 assert!(fetched.is_none());
110 }
111
112 #[tokio::test]
113 async fn test_user_isolation() {
114 let pool = common::setup_test_db().await;
115 let user1 = common::create_test_user(&pool).await;
116 let user2 = common::create_test_user(&pool).await;
117 let repo = SqliteProjectRepository::new(pool);
118
119 let project = NewProject {
120 name: "User 1 Project".to_string(),
121 description: "Belongs to user 1".to_string(),
122 project_type: ProjectType::Job,
123 status: ProjectStatus::Active,
124 };
125
126 let created = repo.create(user1, project).await.expect("Failed to create project");
127
128 // User 1 can see their project
129 let user1_projects = repo.list_all(user1).await.expect("Failed to list");
130 assert_eq!(user1_projects.len(), 1);
131
132 // User 2 cannot see user 1's project
133 let user2_projects = repo.list_all(user2).await.expect("Failed to list");
134 assert_eq!(user2_projects.len(), 0);
135
136 // User 2 cannot access by ID either
137 let fetched = repo.get_by_id(created.id, user2).await.expect("Failed to get");
138 assert!(fetched.is_none());
139 }
140