summaryrefslogtreecommitdiff
path: root/modules/swarm/tests/run.cpp
blob: b7cd8f511b6467761ad543fd972cf2605364a86f (plain)
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
#include <forstio/test/suite.hpp>

#include "../c++/run.hpp"
#include "../c++/wire.hpp"

#include <set>
#include <string>

namespace {
namespace sch {
using namespace kel::lbm::sch;
}
using namespace kel::lbm;
using namespace kel::lbm::swarm;

/// 2026-11-12T09:45:01Z, as milliseconds since the epoch.
constexpr uint64_t reference_ms = 1794476701000ull;

SAW_TEST("Run / the id has the documented shape"){
	// Pinned exactly rather than pattern matched: make_run_id takes its clock
	// and entropy, so the whole string is determined and a drift in either
	// half should fail loudly.
	const std::string id = make_run_id(reference_ms, 0xa3f19cull);
	SAW_EXPECT(id == "20261112T094501Z-a3f19c",
		std::string{"unexpected run id: "} + id);
	SAW_EXPECT(id.size() == 23u, "and the fixed width the sink relies on");
}

SAW_TEST("Run / only the low 24 bits of entropy are used"){
	const std::string a = make_run_id(reference_ms, 0xffffffffffffffffull);
	SAW_EXPECT(a == "20261112T094501Z-ffffff", "the top bits are discarded");

	const std::string b = make_run_id(reference_ms, 0x0ull);
	SAW_EXPECT(b == "20261112T094501Z-000000", "and zero pads rather than shortens");
}

SAW_TEST("Run / ids sort chronologically as plain strings"){
	// The point of the format: `ls` and a std::map give time order for free,
	// with no parsing anywhere.
	const std::string earlier = make_run_id(reference_ms, 0xffffffull);
	const std::string later = make_run_id(reference_ms + 1000u, 0x000000ull);

	SAW_EXPECT(earlier < later,
		"A later run must sort after an earlier one even with lower entropy");

	// Across a month and a year boundary, where a naive format breaks.
	SAW_EXPECT(make_run_id(reference_ms, 0u)
		< make_run_id(reference_ms + 30ull * 86400000ull, 0u),
		"and across a month");
}

SAW_TEST("Run / the civil date conversion handles the awkward cases"){
	using kel::lbm::swarm::impl::civil_from_days;

	// The epoch itself.
	{
		const auto d = civil_from_days(0);
		SAW_EXPECT(d.year == 1970 and d.month == 1u and d.day == 1u, "epoch");
	}
	// A leap day, which is where a hand-rolled conversion usually goes wrong.
	{
		const auto d = civil_from_days(19782);  // 2024-02-29
		SAW_EXPECT(d.year == 2024 and d.month == 2u and d.day == 29u,
			"2024 is a leap year and the 29th exists");
	}
	// 2000 was a leap year despite being a century.
	{
		const auto d = civil_from_days(11016);  // 2000-02-29
		SAW_EXPECT(d.year == 2000 and d.month == 2u and d.day == 29u,
			"the 400 year rule");
	}
	// The day after the 2024 leap day, so an off-by-one shows.
	{
		const auto d = civil_from_days(19783);
		SAW_EXPECT(d.year == 2024 and d.month == 3u and d.day == 1u, "march 1st");
	}
}

SAW_TEST("Run / midnight and the last second of a day format correctly"){
	// 2026-11-12T00:00:00Z
	const uint64_t midnight = (reference_ms / 86400000ull) * 86400000ull;
	SAW_EXPECT(make_run_id(midnight, 0u) == "20261112T000000Z-000000",
		"midnight is all zeroes, not blank");

	SAW_EXPECT(make_run_id(midnight + 86399000ull, 0u)
		== "20261112T235959Z-000000", "and the last second is 235959");

	// One more second rolls the date rather than producing 24:00:00.
	SAW_EXPECT(make_run_id(midnight + 86400000ull, 0u)
		== "20261113T000000Z-000000", "which rolls into the next day");
}

/**
 * The sink uses a run id as a directory name, so this is the check that stops
 * a hostile id escaping the storage root.
 */
SAW_TEST("Run / validation rejects anything that is not the exact shape"){
	SAW_EXPECT(is_run_id(make_run_id(reference_ms, 0xabcdefull)),
		"what make_run_id produces must validate");

	const char *bad[] = {
		"",
		"20261112T094501Z",                 // no entropy
		"20261112T094501Z-a3f19",           // one short
		"20261112T094501Z-a3f19cd",         // one long
		"20261112t094501Z-a3f19c",          // lowercase separator
		"20261112T094501Z-A3F19C",          // uppercase hex
		"20261112T094501Z-a3f19g",          // 'g' is not hex
		"2026111 T094501Z-a3f19c",          // space
		"../../etc/passwd000000Z-a3f19c",   // the reason this function exists
		"20261112T094501Z/a3f19c",          // a separator that is a path one
	};

	for(const char *id : bad){
		SAW_EXPECT(not is_run_id(id),
			std::string{"must be rejected: "} + id);
	}
}

SAW_TEST("Run / distinct entropy gives distinct ids within one second"){
	std::set<std::string> seen;
	for(uint64_t e = 0u; e < 512u; ++e){
		seen.insert(make_run_id(reference_ms, e));
	}
	SAW_EXPECT(seen.size() == 512u,
		"Two runs started in the same second must not collide");
}

SAW_TEST("Run / a run descriptor round trips on the wire"){
	auto start = make_message<sch::MsgRunStart>(msg::run_start, "orch", 0u);

	auto &run = start.get<"run">();
	run.get<"run_id">().set(make_run_id(reference_ms, 0xa3f19cull));
	run.get<"name">().set(std::string{"poiseuille 1024x256"});
	run.get<"created_at_ms">().set(reference_ms);
	run.get<"schema_version">().set(std::string{schema_version});
	run.get<"halo_exchange">().set(false);
	run.get<"params_json">().set(std::string{R"({"nx":1024,"ny":256})"});

	auto eo_text = encode_message<sch::MsgRunStart>(start);
	SAW_EXPECT(not eo_text.is_error(), "a run start encodes");

	auto eo_hdr = peek_header(eo_text.get_value());
	SAW_EXPECT(not eo_hdr.is_error(), "and routes");
	SAW_EXPECT(header_type(eo_hdr.get_value()) == msg::run_start, "as a run start");

	auto eo_back = decode_message<sch::MsgRunStart>(eo_text.get_value());
	SAW_EXPECT(not eo_back.is_error(), "and decodes");

	const auto &back = eo_back.get_value().get<"run">();
	SAW_EXPECT(back.get<"run_id">().stl_view() == "20261112T094501Z-a3f19c",
		"the id survives");
	SAW_EXPECT(not back.get<"halo_exchange">().get(),
		"and the record that the seams were clamped survives with it");
	SAW_EXPECT(back.get<"params_json">().stl_view() == R"({"nx":1024,"ny":256})",
		"the opaque params survive being nested inside JSON");
}
}