max / goingson

4.0 KB · 126 lines History Blame Raw

1	//! Integration tests for event repository operations.
2
3	use chrono::{Duration, Utc};
4	use goingson_core::{NewEvent, Recurrence, UpdateEvent};
5
6	use crate::test_utils::{create_test_project, setup_test_state};
7
8	#[tokio::test]
9	async fn create_and_list_event() {
10	let (state, user_id) = setup_test_state().await;
11
12	let start = Utc::now() + Duration::days(1);
13	let end = start + Duration::hours(1);
14
15	let new_event = NewEvent::builder("Team Meeting", start)
16	.end_time(end)
17	.description("Weekly sync")
18	.location("Room A")
19	.build();
20
21	let event = state.events.create(user_id, new_event).await.unwrap();
22	assert_eq!(event.title, "Team Meeting");
23	assert_eq!(event.description, "Weekly sync");
24	assert_eq!(event.location, Some("Room A".to_string()));
25
26	let events = state.events.list_all(user_id).await.unwrap();
27	assert_eq!(events.len(), 1);
28	assert_eq!(events[0].title, "Team Meeting");
29	}
30
31	#[tokio::test]
32	async fn create_event_with_project() {
33	let (state, user_id) = setup_test_state().await;
34	let project_id = create_test_project(&state, user_id).await;
35
36	let start = Utc::now() + Duration::days(2);
37
38	let new_event = NewEvent::builder("Project Review", start)
39	.project_id(project_id)
40	.build();
41
42	let event = state.events.create(user_id, new_event).await.unwrap();
43	assert_eq!(event.project_id, Some(project_id));
44
45	// List for project
46	let project_events = state
47	.events
48	.list_by_project(user_id, project_id)
49	.await
50	.unwrap();
51	assert_eq!(project_events.len(), 1);
52	assert_eq!(project_events[0].title, "Project Review");
53	}
54
55	#[tokio::test]
56	async fn update_event() {
57	let (state, user_id) = setup_test_state().await;
58
59	let start = Utc::now() + Duration::days(1);
60	let new_event = NewEvent::builder("Original Title", start).build();
61
62	let event = state.events.create(user_id, new_event).await.unwrap();
63
64	let new_start = Utc::now() + Duration::days(3);
65	let update = UpdateEvent {
66	project_id: None,
67	contact_id: None,
68	title: "Updated Title".to_string(),
69	description: "Added description".to_string(),
70	start_time: new_start,
71	end_time: Some(new_start + Duration::hours(2)),
72	location: Some("New Location".to_string()),
73	linked_task_id: None,
74	recurrence: Recurrence::None,
75	recurrence_rule: None,
76	block_type: None,
77	reminder_offsets_seconds: Vec::new(),
78	};
79
80	let updated = state
81	.events
82	.update(event.id, user_id, update)
83	.await
84	.unwrap()
85	.unwrap();
86	assert_eq!(updated.title, "Updated Title");
87	assert_eq!(updated.description, "Added description");
88	assert_eq!(updated.location, Some("New Location".to_string()));
89	}
90
91	#[tokio::test]
92	async fn list_upcoming_events() {
93	let (state, user_id) = setup_test_state().await;
94
95	// Create a future event (within 7 days)
96	let soon = Utc::now() + Duration::days(2);
97	let future_event = NewEvent::builder("Soon Event", soon).build();
98	state.events.create(user_id, future_event).await.unwrap();
99
100	// Create a far-future event (beyond 7 days)
101	let far = Utc::now() + Duration::days(30);
102	let far_event = NewEvent::builder("Far Event", far).build();
103	state.events.create(user_id, far_event).await.unwrap();
104
105	// List upcoming (next 7 days)
106	let upcoming = state.events.get_upcoming(user_id, 7).await.unwrap();
107	assert_eq!(upcoming.len(), 1);
108	assert_eq!(upcoming[0].title, "Soon Event");
109	}
110
111	#[tokio::test]
112	async fn delete_event() {
113	let (state, user_id) = setup_test_state().await;
114
115	let start = Utc::now() + Duration::days(1);
116	let new_event = NewEvent::builder("Event to Delete", start).build();
117
118	let event = state.events.create(user_id, new_event).await.unwrap();
119
120	let deleted = state.events.delete(event.id, user_id).await.unwrap();
121	assert!(deleted);
122
123	let fetched = state.events.get_by_id(event.id, user_id).await.unwrap();
124	assert!(fetched.is_none());
125	}
126