lib/trace/src/test.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

 1 const std = @import("std");
 2 const sys = @import("sys");
 3 const subject = @import("root.zig");
 4 const store_test = @import("store/test.zig");
 5 
 6 const Session = subject.Session;
 7 const Manifest = subject.Manifest;
 8 const TraceLimits = subject.TraceLimits;
 9 const TraceReader = subject.TraceReader;
10 const TraceReaderLimits = subject.TraceReaderLimits;
11 const TraceReaderStorage = subject.TraceReaderStorage;
12 const TraceWriter = subject.TraceWriter;
13 const TraceWriterLimits = subject.TraceWriterLimits;
14 const TraceWriterStorage = subject.TraceWriterStorage;
15 
16 test "trace package namespace" {
17     std.testing.refAllDecls(subject);
18     std.testing.refAllDecls(store_test);
19     _ = @import("store/reader/stream.zig");
20 }
21 
22 test "record and replay sessions stream through root-composed storage" {
23     comptime {
24         @stardustClaim(
25             @import("alloc_phase").capacity.witness(@import("./store/reader/root.zig").TraceReaderStorage, "trace_trace_reader_root"),
26             null,
27             null,
28             null,
29             null,
30             null,
31             null,
32         );
33     }
34     comptime {
35         @stardustClaim(
36             @import("alloc_phase").capacity.witness(@import("./store/writer/root.zig").Storage, "trace_trace_writer_root"),
37             null,
38             null,
39             null,
40             null,
41             null,
42             null,
43         );
44     }
45 
46     const allocator = std.testing.allocator;
47     var tmp = std.testing.tmpDir(.{});
48     defer tmp.cleanup();
49     const tmp_root = try tmp.parent_dir.realPathFileAlloc(sys.fs.debugIo(), tmp.sub_path[0..], allocator);
50     defer allocator.free(tmp_root);
51     const path = try sys.path.join(allocator, &.{ tmp_root, "session.trace" });
52     defer allocator.free(path);
53 
54     const manifest = Manifest{ .build_id = "session-integration" };
55     const limits = TraceLimits{ .max_event_bytes = 1024, .max_chunk_bytes = 4096 };
56     var writer_storage = try TraceWriterStorage.init(
57         allocator,
58         TraceWriterLimits.fromOpen(path, manifest, limits),
59     );
60     defer writer_storage.deinit(allocator);
61     writer_storage.activate();
62     var trace_writer: TraceWriter = .{};
63     try trace_writer.open(&writer_storage, path, manifest, limits);
64     defer trace_writer.deinit();
65     var recording = Session.initRecord(allocator, trace_writer.sink());
66     defer recording.deinit();
67     _ = try recording.sessionStart(1, "integration");
68     for (0..100) |index| {
69         _ = try recording.userEvent(1, "sample", if (index % 2 == 0) "even" else "odd");
70     }
71     _ = try recording.sessionEnd(1, 0);
72     try trace_writer.finish();
73 
74     var reader_storage = try TraceReaderStorage.init(
75         allocator,
76         TraceReaderLimits.fromOpen(path, limits),
77     );
78     defer reader_storage.deinit(allocator);
79     reader_storage.activate();
80     var trace_reader: TraceReader = .{};
81     try trace_reader.open(&reader_storage, path);
82     defer trace_reader.deinit();
83     var replaying = Session.initReplay(allocator, trace_reader.source());
84     defer replaying.deinit();
85     _ = try replaying.sessionStart(1, "integration");
86     for (0..100) |index| {
87         _ = try replaying.userEvent(1, "sample", if (index % 2 == 0) "even" else "odd");
88     }
89     _ = try replaying.sessionEnd(1, 0);
90     try replaying.verifyReplayComplete();
91     try std.testing.expectEqual(@as(u64, 102), replaying.replayProgress().event_count);
92 }