Skip to content

Commit 012d846

Browse files
ccamelccamel
committed
test(contract): add comprehensive unit tests for event_sourcing_interval module
1 parent 6a020f2 commit 012d846

1 file changed

Lines changed: 152 additions & 0 deletions

File tree

‎apps/event_sourcing_contract/test/event_sourcing_interval_tests.erl‎

Lines changed: 152 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,152 @@
1+
-module(event_sourcing_interval_tests).
2+
3+
-include_lib("eunit/include/eunit.hrl").
4+
5+
%%% Test suite
6+
7+
suite_test_() ->
8+
{foreach, fun setup/0, fun teardown/1, [
9+
{"new_interval_creation", fun new_interval_creation/0},
10+
{"new_interval_validation", fun new_interval_validation/0},
11+
{"is_empty_check", fun is_empty_check/0},
12+
{"advance_interval", fun advance_interval/0},
13+
{"lower_bound_access", fun lower_bound_access/0},
14+
{"upper_bound_access", fun upper_bound_access/0},
15+
{"interval_properties", fun interval_properties/0},
16+
{"edge_cases", fun edge_cases/0}
17+
]}.
18+
19+
setup() ->
20+
ok.
21+
22+
teardown(_) ->
23+
ok.
24+
25+
%%% Test cases
26+
27+
new_interval_creation() ->
28+
% Test basic interval creation [0, 10)
29+
Interval1 = event_sourcing_interval:new(0, 10),
30+
?assertEqual({0, 10}, Interval1),
31+
32+
% Test unbounded interval [5, +∞)
33+
Interval2 = event_sourcing_interval:new(5, infinity),
34+
?assertEqual({5, infinity}, Interval2),
35+
36+
% Test non-empty single-element interval [7, 8)
37+
Interval3 = event_sourcing_interval:new(7, 8),
38+
?assertEqual({7, 8}, Interval3).
39+
40+
new_interval_validation() ->
41+
% Test valid cases
42+
?assertEqual({1, 5}, event_sourcing_interval:new(1, 5)),
43+
?assertEqual({10, infinity}, event_sourcing_interval:new(10, infinity)),
44+
?assertEqual({5, 5}, event_sourcing_interval:new(5, 5)),
45+
46+
% Test invalid cases - should throw function_clause error due to guard failure
47+
?assertError(function_clause, event_sourcing_interval:new(-1, 5)),
48+
% From > To
49+
?assertError(function_clause, event_sourcing_interval:new(5, 3)),
50+
?assertError(function_clause, event_sourcing_interval:new(5, -1)).
51+
52+
is_empty_check() ->
53+
% Test non-empty intervals (half-open [From, To))
54+
55+
% [0, 10) has 10 elements
56+
?assertEqual(false, event_sourcing_interval:is_empty({0, 10})),
57+
% [5, 6) has 1 element
58+
?assertEqual(false, event_sourcing_interval:is_empty({5, 6})),
59+
?assertEqual(false, event_sourcing_interval:is_empty({1, infinity})),
60+
61+
% Test empty intervals (From >= To)
62+
63+
% [5, 5) is empty
64+
?assertEqual(true, event_sourcing_interval:is_empty({5, 5})),
65+
% [5, 3) is empty
66+
?assertEqual(true, event_sourcing_interval:is_empty({5, 3})),
67+
% [10, 9) is empty
68+
?assertEqual(true, event_sourcing_interval:is_empty({10, 9})),
69+
70+
% Unbounded intervals are never empty
71+
?assertEqual(false, event_sourcing_interval:is_empty({0, infinity})),
72+
?assertEqual(false, event_sourcing_interval:is_empty({100, infinity})).
73+
74+
advance_interval() ->
75+
% Test advancing bounded intervals
76+
Interval1 = event_sourcing_interval:new(0, 10),
77+
Advanced1 = event_sourcing_interval:advance(Interval1, 3),
78+
?assertEqual({3, 10}, Advanced1),
79+
80+
% Test advancing unbounded intervals
81+
Interval2 = event_sourcing_interval:new(5, infinity),
82+
Advanced2 = event_sourcing_interval:advance(Interval2, 7),
83+
?assertEqual({12, infinity}, Advanced2),
84+
85+
% Test advancing by zero
86+
Interval3 = event_sourcing_interval:new(2, 8),
87+
Advanced3 = event_sourcing_interval:advance(Interval3, 0),
88+
?assertEqual({2, 8}, Advanced3),
89+
90+
% Test advancing to boundary (creates empty interval)
91+
Interval4 = event_sourcing_interval:new(3, 7),
92+
Advanced4 = event_sourcing_interval:advance(Interval4, 4),
93+
?assertEqual({7, 7}, Advanced4),
94+
?assertEqual(true, event_sourcing_interval:is_empty(Advanced4)),
95+
96+
% Test advancing beyond boundary (creates empty interval)
97+
Interval5 = event_sourcing_interval:new(3, 7),
98+
Advanced5 = event_sourcing_interval:advance(Interval5, 5),
99+
?assertEqual({8, 7}, Advanced5),
100+
?assertEqual(true, event_sourcing_interval:is_empty(Advanced5)).
101+
102+
lower_bound_access() ->
103+
% Test lower bound extraction
104+
?assertEqual(0, event_sourcing_interval:lower_bound({0, 10})),
105+
?assertEqual(5, event_sourcing_interval:lower_bound({5, infinity})),
106+
?assertEqual(7, event_sourcing_interval:lower_bound({7, 8})),
107+
?assertEqual(100, event_sourcing_interval:lower_bound({100, 200})).
108+
109+
upper_bound_access() ->
110+
% Test upper bound extraction
111+
?assertEqual(10, event_sourcing_interval:upper_bound({0, 10})),
112+
?assertEqual(infinity, event_sourcing_interval:upper_bound({5, infinity})),
113+
?assertEqual(8, event_sourcing_interval:upper_bound({7, 8})),
114+
?assertEqual(200, event_sourcing_interval:upper_bound({100, 200})).
115+
116+
interval_properties() ->
117+
% Test that intervals maintain invariants for half-open intervals [From, To)
118+
Interval1 = event_sourcing_interval:new(0, 10),
119+
?assert(
120+
event_sourcing_interval:lower_bound(Interval1) <
121+
event_sourcing_interval:upper_bound(Interval1) orelse
122+
event_sourcing_interval:upper_bound(Interval1) =:= infinity
123+
),
124+
125+
Interval2 = event_sourcing_interval:new(5, infinity),
126+
?assert(event_sourcing_interval:lower_bound(Interval2) >= 0),
127+
?assert(event_sourcing_interval:upper_bound(Interval2) =:= infinity),
128+
129+
% Test that advancing preserves the upper bound
130+
Original = event_sourcing_interval:new(2, 15),
131+
Advanced = event_sourcing_interval:advance(Original, 3),
132+
?assertEqual(
133+
event_sourcing_interval:upper_bound(Original), event_sourcing_interval:upper_bound(Advanced)
134+
).
135+
136+
edge_cases() ->
137+
% Test single-element interval [0, 1)
138+
SingleElement = event_sourcing_interval:new(0, 1),
139+
?assertEqual(false, event_sourcing_interval:is_empty(SingleElement)),
140+
?assertEqual(0, event_sourcing_interval:lower_bound(SingleElement)),
141+
?assertEqual(1, event_sourcing_interval:upper_bound(SingleElement)),
142+
143+
% Test large numbers
144+
LargeInterval = event_sourcing_interval:new(1000000, 2000000),
145+
?assertEqual(false, event_sourcing_interval:is_empty(LargeInterval)),
146+
AdvancedLarge = event_sourcing_interval:advance(LargeInterval, 500000),
147+
?assertEqual({1500000, 2000000}, AdvancedLarge),
148+
149+
% Test advancing unbounded interval by large amount
150+
Unbounded = event_sourcing_interval:new(0, infinity),
151+
AdvancedUnbounded = event_sourcing_interval:advance(Unbounded, 1000000),
152+
?assertEqual({1000000, infinity}, AdvancedUnbounded).

0 commit comments

Comments
 (0)