Repository navigation
Expand file tree
/
Copy pathEventQueueTest.java
More file actions
405 lines (328 loc) · 14.1 KB
/
Copy pathEventQueueTest.java
File metadata and controls
405 lines (328 loc) · 14.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
package io.a2a.server.events;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import io.a2a.spec.Artifact;
import io.a2a.spec.Event;
import io.a2a.spec.JSONRPCError;
import io.a2a.spec.Message;
import io.a2a.spec.Task;
import io.a2a.spec.TaskArtifactUpdateEvent;
import io.a2a.spec.TaskNotFoundError;
import io.a2a.spec.TaskState;
import io.a2a.spec.TaskStatus;
import io.a2a.spec.TaskStatusUpdateEvent;
import io.a2a.spec.TextPart;
import io.a2a.util.Utils;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
public class EventQueueTest {
private EventQueue eventQueue;
private static final String MINIMAL_TASK = """
{
"id": "123",
"contextId": "session-xyz",
"status": {"state": "submitted"}
}
""";
private static final String MESSAGE_PAYLOAD = """
{
"role": "agent",
"parts": [{"text": "test message"}],
"messageId": "111"
}
""";
@BeforeEach
public void init() {
eventQueue = EventQueue.builder().build();
}
@Test
public void testConstructorDefaultQueueSize() {
EventQueue queue = EventQueue.builder().build();
assertEquals(EventQueue.DEFAULT_QUEUE_SIZE, queue.getQueueSize());
}
@Test
public void testConstructorCustomQueueSize() {
int customSize = 500;
EventQueue queue = EventQueue.builder().queueSize(customSize).build();
assertEquals(customSize, queue.getQueueSize());
}
@Test
public void testConstructorInvalidQueueSize() {
// Test zero queue size
assertThrows(IllegalArgumentException.class, () -> EventQueue.builder().queueSize(0).build());
// Test negative queue size
assertThrows(IllegalArgumentException.class, () -> EventQueue.builder().queueSize(-10).build());
}
@Test
public void testTapCreatesChildQueue() {
EventQueue parentQueue = EventQueue.builder().build();
EventQueue childQueue = parentQueue.tap();
assertNotNull(childQueue);
assertNotSame(parentQueue, childQueue);
assertEquals(EventQueue.DEFAULT_QUEUE_SIZE, childQueue.getQueueSize());
}
@Test
public void testTapOnChildQueueThrowsException() {
EventQueue parentQueue = EventQueue.builder().build();
EventQueue childQueue = parentQueue.tap();
assertThrows(IllegalStateException.class, () -> childQueue.tap());
}
@Test
public void testEnqueueEventPropagagesToChildren() throws Exception {
EventQueue parentQueue = EventQueue.builder().build();
EventQueue childQueue = parentQueue.tap();
Event event = Utils.unmarshalFrom(MINIMAL_TASK, Task.class);
parentQueue.enqueueEvent(event);
// Event should be available in both parent and child queues
Event parentEvent = parentQueue.dequeueEventItem(-1).getEvent();
Event childEvent = childQueue.dequeueEventItem(-1).getEvent();
assertSame(event, parentEvent);
assertSame(event, childEvent);
}
@Test
public void testMultipleChildQueuesReceiveEvents() throws Exception {
EventQueue parentQueue = EventQueue.builder().build();
EventQueue childQueue1 = parentQueue.tap();
EventQueue childQueue2 = parentQueue.tap();
Event event1 = Utils.unmarshalFrom(MINIMAL_TASK, Task.class);
Event event2 = Utils.unmarshalFrom(MESSAGE_PAYLOAD, Message.class);
parentQueue.enqueueEvent(event1);
parentQueue.enqueueEvent(event2);
// All queues should receive both events
assertSame(event1, parentQueue.dequeueEventItem(-1).getEvent());
assertSame(event2, parentQueue.dequeueEventItem(-1).getEvent());
assertSame(event1, childQueue1.dequeueEventItem(-1).getEvent());
assertSame(event2, childQueue1.dequeueEventItem(-1).getEvent());
assertSame(event1, childQueue2.dequeueEventItem(-1).getEvent());
assertSame(event2, childQueue2.dequeueEventItem(-1).getEvent());
}
@Test
public void testChildQueueDequeueIndependently() throws Exception {
EventQueue parentQueue = EventQueue.builder().build();
EventQueue childQueue1 = parentQueue.tap();
EventQueue childQueue2 = parentQueue.tap();
Event event = Utils.unmarshalFrom(MINIMAL_TASK, Task.class);
parentQueue.enqueueEvent(event);
// Dequeue from child1 first
Event child1Event = childQueue1.dequeueEventItem(-1).getEvent();
assertSame(event, child1Event);
// child2 should still have the event available
Event child2Event = childQueue2.dequeueEventItem(-1).getEvent();
assertSame(event, child2Event);
// Parent should still have the event available
Event parentEvent = parentQueue.dequeueEventItem(-1).getEvent();
assertSame(event, parentEvent);
}
@Test
public void testCloseImmediatePropagationToChildren() throws Exception {
EventQueue parentQueue = EventQueue.builder().build();
EventQueue childQueue = parentQueue.tap();
// Add events to both parent and child
Event event = Utils.unmarshalFrom(MINIMAL_TASK, Task.class);
parentQueue.enqueueEvent(event);
assertFalse(childQueue.isClosed());
try {
assertNotNull(childQueue.dequeueEventItem(-1)); // Child has the event
} catch (EventQueueClosedException e) {
// This is fine if queue closed before dequeue
}
// Add event again for immediate close test
parentQueue.enqueueEvent(event);
// Close with immediate=true
parentQueue.close(true);
assertTrue(parentQueue.isClosed());
assertTrue(childQueue.isClosed());
// Child queue should be cleared due to immediate close
// Child queue should be cleared and closed, so dequeueing should throw
assertThrows(EventQueueClosedException.class, () -> childQueue.dequeueEventItem(-1));
}
@Test
public void testEnqueueEventWhenClosed() throws Exception {
EventQueue queue = EventQueue.builder().build();
Event event = Utils.unmarshalFrom(MINIMAL_TASK, Task.class);
queue.close(); // Close the queue first
assertTrue(queue.isClosed());
// MainQueue accepts events even when closed (for replication support)
// This ensures late-arriving replicated events can be enqueued to closed queues
queue.enqueueEvent(event);
// Event should be available for dequeuing
Event dequeuedEvent = queue.dequeueEventItem(-1).getEvent();
assertSame(event, dequeuedEvent);
// Now queue is closed and empty, should throw exception
assertThrows(EventQueueClosedException.class, () -> queue.dequeueEventItem(-1));
}
@Test
public void testDequeueEventWhenClosedAndEmpty() throws Exception {
EventQueue queue = EventQueue.builder().build();
queue.close();
assertTrue(queue.isClosed());
// Dequeue from closed empty queue should throw exception
assertThrows(EventQueueClosedException.class, () -> queue.dequeueEventItem(-1));
}
@Test
public void testDequeueEventWhenClosedButHasEvents() throws Exception {
EventQueue queue = EventQueue.builder().build();
Event event = Utils.unmarshalFrom(MINIMAL_TASK, Task.class);
queue.enqueueEvent(event);
queue.close(); // Graceful close - events should remain
assertTrue(queue.isClosed());
// Should still be able to dequeue existing events
Event dequeuedEvent = queue.dequeueEventItem(-1).getEvent();
assertSame(event, dequeuedEvent);
// Now queue is closed and empty, should throw exception
assertThrows(EventQueueClosedException.class, () -> queue.dequeueEventItem(-1));
}
@Test
public void testEnqueueAndDequeueEvent() throws Exception {
Event event = Utils.unmarshalFrom(MESSAGE_PAYLOAD, Message.class);
eventQueue.enqueueEvent(event);
Event dequeuedEvent = eventQueue.dequeueEventItem(200).getEvent();
assertSame(event, dequeuedEvent);
}
@Test
public void testDequeueEventNoWait() throws Exception {
Event event = Utils.unmarshalFrom(MINIMAL_TASK, Task.class);
eventQueue.enqueueEvent(event);
Event dequeuedEvent = eventQueue.dequeueEventItem(-1).getEvent();
assertSame(event, dequeuedEvent);
}
@Test
public void testDequeueEventEmptyQueueNoWait() throws Exception {
EventQueueItem item = eventQueue.dequeueEventItem(-1);
assertNull(item);
}
@Test
public void testDequeueEventWait() throws Exception {
Event event = TaskStatusUpdateEvent.builder()
.taskId("task-123")
.contextId("session-xyz")
.status(new TaskStatus(TaskState.WORKING))
.isFinal(true)
.build();
eventQueue.enqueueEvent(event);
Event dequeuedEvent = eventQueue.dequeueEventItem(1000).getEvent();
assertSame(event, dequeuedEvent);
}
@Test
public void testTaskDone() throws Exception {
Event event = TaskArtifactUpdateEvent.builder()
.taskId("task-123")
.contextId("session-xyz")
.artifact(Artifact.builder()
.artifactId("11")
.parts(new TextPart("text"))
.build())
.build();
eventQueue.enqueueEvent(event);
Event dequeuedEvent = eventQueue.dequeueEventItem(1000).getEvent();
assertSame(event, dequeuedEvent);
eventQueue.taskDone();
}
@Test
public void testEnqueueDifferentEventTypes() throws Exception {
List<Event> events = List.of(
new TaskNotFoundError(),
new JSONRPCError(111, "rpc error", null));
for (Event event : events) {
eventQueue.enqueueEvent(event);
Event dequeuedEvent = eventQueue.dequeueEventItem(100).getEvent();
assertSame(event, dequeuedEvent);
}
}
/**
* Test close behavior sets flag and handles graceful close.
* Backported from Python test: test_close_sets_flag_and_handles_internal_queue_old_python
*/
@Test
public void testCloseGracefulSetsFlag() throws Exception {
Event event = Utils.unmarshalFrom(MINIMAL_TASK, Task.class);
eventQueue.enqueueEvent(event);
eventQueue.close(false); // Graceful close
assertTrue(eventQueue.isClosed());
}
/**
* Test immediate close behavior.
* Backported from Python test behavior
*/
@Test
public void testCloseImmediateClearsQueue() throws Exception {
Event event = Utils.unmarshalFrom(MINIMAL_TASK, Task.class);
eventQueue.enqueueEvent(event);
eventQueue.close(true); // Immediate close
assertTrue(eventQueue.isClosed());
// After immediate close, queue should be cleared
// Attempting to dequeue should return null or throw exception
try {
EventQueueItem item = eventQueue.dequeueEventItem(-1);
// If we get here, the item should be null (queue was cleared)
assertNull(item);
} catch (EventQueueClosedException e) {
// This is also acceptable - queue is closed
}
}
/**
* Test that close is idempotent.
* Backported from Python test: test_close_idempotent
*/
@Test
public void testCloseIdempotent() throws Exception {
eventQueue.close();
assertTrue(eventQueue.isClosed());
// Calling close again should not cause issues
eventQueue.close();
assertTrue(eventQueue.isClosed());
// Test with immediate close as well
EventQueue eventQueue2 = EventQueue.builder().build();
eventQueue2.close(true);
assertTrue(eventQueue2.isClosed());
eventQueue2.close(true);
assertTrue(eventQueue2.isClosed());
}
/**
* Test that child queues are NOT automatically closed when parent closes gracefully.
* Children must close themselves, which then notifies parent via reference counting.
*/
@Test
public void testCloseChildQueues() throws Exception {
EventQueue childQueue = eventQueue.tap();
assertTrue(childQueue != null);
// Graceful close - parent closes but children remain open
eventQueue.close();
assertTrue(eventQueue.isClosed());
assertFalse(childQueue.isClosed()); // Child NOT closed on graceful parent close
// Immediate close - parent force-closes all children
EventQueue parentQueue2 = EventQueue.builder().build();
EventQueue childQueue2 = parentQueue2.tap();
parentQueue2.close(true); // immediate=true
assertTrue(parentQueue2.isClosed());
assertTrue(childQueue2.isClosed()); // Child IS closed on immediate parent close
}
/**
* Test reference counting: MainQueue stays open while children are active,
* closes automatically when last child closes.
*/
@Test
public void testMainQueueReferenceCountingStaysOpenWithActiveChildren() throws Exception {
EventQueue mainQueue = EventQueue.builder().build();
EventQueue child1 = mainQueue.tap();
EventQueue child2 = mainQueue.tap();
// Close child1
child1.close();
// MainQueue should still be open (child2 active)
assertFalse(mainQueue.isClosed());
assertTrue(child1.isClosed());
assertFalse(child2.isClosed());
// Close child2
child2.close();
// Now MainQueue should auto-close (no children left)
assertTrue(mainQueue.isClosed());
assertTrue(child2.isClosed());
}
}