Skip to content

Commit 05aaec4

Browse files
jmfrank63jmfrank63
committed
stable formatting
1 parent ff1e597 commit 05aaec4

File tree

10 files changed

+135
-79
lines changed

10 files changed

+135
-79
lines changed

‎governor/src/clock/quanta.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -123,8 +123,7 @@ mod test {
123123
let one_ns = Nanos::new(1);
124124
// let _c1 =
125125
// QuantaUpkeepClock::from_builder(quanta::Upkeep::new(Duration::from_secs(1))).unwrap();
126-
let c = QuantaUpkeepClock::from_interval(Duration::from_secs(1))
127-
.unwrap();
126+
let c = QuantaUpkeepClock::from_interval(Duration::from_secs(1)).unwrap();
128127
let now = c.now();
129128
assert_ne!(now + one_ns, now);
130129
assert_eq!(one_ns, Reference::duration_since(&(now + one_ns), now));

‎governor/src/gcra.rs

+10-6
Original file line numberDiff line numberDiff line change
@@ -122,10 +122,8 @@ impl Gcra {
122122
} else {
123123
let next = cmp::max(tat, t0) + t;
124124
Ok((
125-
MW::allow(
126-
key,
127-
StateSnapshot::new(self.t, self.tau, t0, next)),
128-
next,
125+
MW::allow(key, StateSnapshot::new(self.t, self.tau, t0, next)),
126+
next,
129127
))
130128
}
131129
})
@@ -164,7 +162,10 @@ impl Gcra {
164162
}
165163
}) {
166164
Some(outcome) => outcome,
167-
None => Ok(MW::allow(key, StateSnapshot::new(self.t, self.tau, t0, tau))),
165+
None => Ok(MW::allow(
166+
key,
167+
StateSnapshot::new(self.t, self.tau, t0, tau),
168+
)),
168169
}
169170
}
170171

@@ -262,7 +263,10 @@ impl Gcra {
262263
}
263264
}) {
264265
Some(outcome) => outcome,
265-
None => Ok(MW::allow(key, StateSnapshot::new(self.t, self.tau, t0, tau))),
266+
None => Ok(MW::allow(
267+
key,
268+
StateSnapshot::new(self.t, self.tau, t0, tau),
269+
)),
266270
}
267271
}
268272
}

‎governor/src/state/direct.rs

+7-8
Original file line numberDiff line numberDiff line change
@@ -121,14 +121,13 @@ where
121121
&self,
122122
n: NonZeroU32,
123123
) -> Result<MW::PositiveOutcome, NegativeMultiDecision<MW::NegativeOutcome>> {
124-
self.gcra
125-
.test_n_all_peek::<NotKeyed, C::Instant, S, MW>(
126-
self.start,
127-
&NotKeyed::NonKey,
128-
n,
129-
&self.state,
130-
self.clock.now(),
131-
)
124+
self.gcra.test_n_all_peek::<NotKeyed, C::Instant, S, MW>(
125+
self.start,
126+
&NotKeyed::NonKey,
127+
n,
128+
&self.state,
129+
self.clock.now(),
130+
)
132131
}
133132
}
134133

‎governor/src/state/keyed.rs

+3-8
Original file line numberDiff line numberDiff line change
@@ -99,18 +99,14 @@ where
9999
}
100100

101101
pub fn peek_key(&self, key: &K) -> Result<MW::PositiveOutcome, MW::NegativeOutcome> {
102-
self.gcra.peek_test::<K, C::Instant, S, MW>(
103-
self.start,
104-
key,
105-
&self.state,
106-
self.clock.now(),
107-
)
102+
self.gcra
103+
.peek_test::<K, C::Instant, S, MW>(self.start, key, &self.state, self.clock.now())
108104
}
109105

110106
pub fn reset_key(&self, key: &K) {
111107
self.state.reset(key);
112108
}
113-
109+
114110
/// Allow *only all* `n` cells through the rate limiter for the given key.
115111
///
116112
/// This method can succeed in only one way and fail in two ways:
@@ -152,7 +148,6 @@ where
152148
self.clock.now(),
153149
)
154150
}
155-
156151
}
157152

158153
/// Keyed rate limiters that can be "cleaned up".

‎governor/src/state/keyed/hashmap.rs

+4-3
Original file line numberDiff line numberDiff line change
@@ -48,10 +48,11 @@ impl<K: Hash + Eq + Clone> StateStore for HashMapStateStore<K> {
4848
return Some(v.measure_and_peek_one(f));
4949
}
5050
// not-so-fast path: make a new entry and measure it.
51-
let entry = (*map)
52-
.entry(key.clone());
51+
let entry = (*map).entry(key.clone());
5352
match entry {
54-
std::collections::hash_map::Entry::Occupied(occupied) => Some(occupied.get().measure_and_peek_one(f)),
53+
std::collections::hash_map::Entry::Occupied(occupied) => {
54+
Some(occupied.get().measure_and_peek_one(f))
55+
}
5556
std::collections::hash_map::Entry::Vacant(_) => None,
5657
}
5758
}

‎governor/tests/direct.rs

+34-35
Original file line numberDiff line numberDiff line change
@@ -42,56 +42,55 @@ fn peek_does_not_change_the_decision() {
4242
let lb = RateLimiter::direct_with_clock(Quota::per_second(nonzero!(2u32)), &clock);
4343
let ms = Duration::from_millis(1);
4444

45+
// no key is always positive outcome
46+
for _ in 0..10 {
47+
clock.advance(ms);
48+
assert_eq!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
49+
}
4550

46-
// no key is always positive outcome
47-
for _ in 0..10 {
48-
clock.advance(ms);
49-
assert_eq!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
50-
}
51+
// use up our burst capacity (2 in the first second):
52+
assert_eq!(Ok(()), lb.check(), "Now: {:?}", clock.now());
5153

52-
// use up our burst capacity (2 in the first second):
53-
assert_eq!(Ok(()), lb.check(), "Now: {:?}", clock.now());
54+
for _ in 0..10 {
55+
clock.advance(ms);
56+
assert_eq!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
57+
}
5458

55-
for _ in 0..10 {
56-
clock.advance(ms);
57-
assert_eq!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
58-
}
59+
clock.advance(ms);
60+
assert_eq!(Ok(()), lb.check(), "Now: {:?}", clock.now());
5961

62+
for _ in 0..10 {
6063
clock.advance(ms);
61-
assert_eq!(Ok(()), lb.check(), "Now: {:?}", clock.now());
64+
assert_ne!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
65+
}
6266

63-
for _ in 0..10 {
64-
clock.advance(ms);
65-
assert_ne!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
66-
}
67+
clock.advance(ms);
68+
assert_ne!(Ok(()), lb.check(), "Now: {:?}", clock.now());
6769

70+
for _ in 0..10 {
6871
clock.advance(ms);
69-
assert_ne!(Ok(()), lb.check(), "Now: {:?}", clock.now());
72+
assert_ne!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
73+
}
7074

71-
for _ in 0..10 {
72-
clock.advance(ms);
73-
assert_ne!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
74-
}
75+
// should be ok again in 1s:
76+
clock.advance(ms * 1000);
77+
assert_eq!(Ok(()), lb.check(), "Now: {:?}", clock.now());
78+
clock.advance(ms);
7579

76-
// should be ok again in 1s:
77-
clock.advance(ms * 1000);
78-
assert_eq!(Ok(()), lb.check(), "Now: {:?}", clock.now());
80+
for _ in 0..10 {
7981
clock.advance(ms);
82+
assert_eq!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
83+
}
8084

81-
for _ in 0..10 {
82-
clock.advance(ms);
83-
assert_eq!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
84-
}
85+
assert_eq!(Ok(()), lb.check());
8586

86-
assert_eq!(Ok(()), lb.check());
87+
clock.advance(ms);
88+
assert_ne!(Ok(()), lb.check(), "{:?}", lb);
8789

90+
for _ in 0..10 {
8891
clock.advance(ms);
89-
assert_ne!(Ok(()), lb.check(), "{:?}", lb);
90-
91-
for _ in 0..10 {
92-
clock.advance(ms);
93-
assert_ne!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
94-
}
92+
assert_ne!(Ok(()), lb.peek(), "Now: {:?}", clock.now());
93+
}
9594
}
9695

9796
#[test]

‎governor/tests/future.rs

+24-6
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,10 @@ fn pauses() {
2323
}
2424
let i = Instant::now();
2525
block_on(lim.until_ready());
26-
assert_ge!(i.elapsed(), Duration::from_millis(PAUSES_DURATION_MIN_MILLIS));
26+
assert_ge!(
27+
i.elapsed(),
28+
Duration::from_millis(PAUSES_DURATION_MIN_MILLIS)
29+
);
2730
}
2831

2932
#[test]
@@ -34,7 +37,10 @@ fn pauses_n() {
3437
}
3538
let i = Instant::now();
3639
block_on(lim.until_n_ready(nonzero!(5u32))).unwrap();
37-
assert_ge!(i.elapsed(), Duration::from_millis(PAUSES_DURATION_MIN_MILLIS));
40+
assert_ge!(
41+
i.elapsed(),
42+
Duration::from_millis(PAUSES_DURATION_MIN_MILLIS)
43+
);
3844
}
3945

4046
#[test]
@@ -49,7 +55,10 @@ fn pauses_keyed() {
4955
}
5056
let i = Instant::now();
5157
block_on(lim.until_key_ready(&1u32));
52-
assert_ge!(i.elapsed(), Duration::from_millis(PAUSES_DURATION_MIN_MILLIS));
58+
assert_ge!(
59+
i.elapsed(),
60+
Duration::from_millis(PAUSES_DURATION_MIN_MILLIS)
61+
);
5362
}
5463

5564
#[test]
@@ -58,7 +67,10 @@ fn proceeds() {
5867

5968
let i = Instant::now();
6069
block_on(lim.until_ready());
61-
assert_le!(i.elapsed(), Duration::from_micros(PROCEEDS_DURATION_MAX_MICROS));
70+
assert_le!(
71+
i.elapsed(),
72+
Duration::from_micros(PROCEEDS_DURATION_MAX_MICROS)
73+
);
6274
}
6375

6476
#[test]
@@ -67,7 +79,10 @@ fn proceeds_n() {
6779

6880
let i = Instant::now();
6981
block_on(lim.until_n_ready(nonzero!(10u32))).unwrap();
70-
assert_le!(i.elapsed(), Duration::from_micros(PROCEEDS_DURATION_MAX_MICROS));
82+
assert_le!(
83+
i.elapsed(),
84+
Duration::from_micros(PROCEEDS_DURATION_MAX_MICROS)
85+
);
7186
}
7287

7388
#[test]
@@ -76,7 +91,10 @@ fn proceeds_keyed() {
7691

7792
let i = Instant::now();
7893
block_on(lim.until_key_ready(&1u32));
79-
assert_le!(i.elapsed(), Duration::from_micros(PROCEEDS_DURATION_MAX_MICROS));
94+
assert_le!(
95+
i.elapsed(),
96+
Duration::from_micros(PROCEEDS_DURATION_MAX_MICROS)
97+
);
8098
}
8199

82100
#[test]

‎governor/tests/keyed_dashmap.rs

+49-9
Original file line numberDiff line numberDiff line change
@@ -54,14 +54,24 @@ fn rejects_too_many_n() {
5454

5555
for key in KEYS {
5656
// use up our burst capacity (2 in the first second):
57-
assert_eq!(Ok(()), lb.check_key_n(key, nonzero!(2u32)), "Now: {:?}", clock.now());
57+
assert_eq!(
58+
Ok(()),
59+
lb.check_key_n(key, nonzero!(2u32)),
60+
"Now: {:?}",
61+
clock.now()
62+
);
5863
clock.advance(ms);
5964

6065
assert_ne!(Ok(()), lb.check_key(key), "Now: {:?}", clock.now());
6166

6267
// should be ok again in 1s:
6368
clock.advance(ms * 1000);
64-
assert_eq!(Ok(()), lb.check_key_n(key, nonzero!(2u32)), "Now: {:?}", clock.now());
69+
assert_eq!(
70+
Ok(()),
71+
lb.check_key_n(key, nonzero!(2u32)),
72+
"Now: {:?}",
73+
clock.now()
74+
);
6575
clock.advance(ms);
6676

6777
assert_ne!(Ok(()), lb.check_key(key), "{:?}", lb);
@@ -136,29 +146,59 @@ fn peek_does_not_change_the_decision_n() {
136146
for key in KEYS {
137147
// no key is always positive outcome
138148
assert!(lb.peek_key_n(key, nonzero!(3u32)).is_err());
139-
assert_eq!(Ok(()), lb.peek_key_n(key, nonzero!(2u32)), "Now: {:?}", clock.now());
149+
assert_eq!(
150+
Ok(()),
151+
lb.peek_key_n(key, nonzero!(2u32)),
152+
"Now: {:?}",
153+
clock.now()
154+
);
140155

141156
// use up our burst capacity (2 in the first second):
142157
assert_eq!(Ok(()), lb.check_key(key), "Now: {:?}", clock.now());
143158

144-
assert_eq!(Ok(()), lb.peek_key_n(key, nonzero!(1u32)), "Now: {:?}", clock.now());
159+
assert_eq!(
160+
Ok(()),
161+
lb.peek_key_n(key, nonzero!(1u32)),
162+
"Now: {:?}",
163+
clock.now()
164+
);
145165
assert!(lb.peek_key_n(key, nonzero!(2u32)).is_err());
146166

147167
clock.advance(ms);
148168
assert_eq!(Ok(()), lb.check_key(key), "Now: {:?}", clock.now());
149169

150-
assert_ne!(Ok(()), lb.peek_key_n(key, nonzero!(2u32)), "Now: {:?}", clock.now());
170+
assert_ne!(
171+
Ok(()),
172+
lb.peek_key_n(key, nonzero!(2u32)),
173+
"Now: {:?}",
174+
clock.now()
175+
);
151176

152177
clock.advance(ms);
153178
assert_ne!(Ok(()), lb.check_key(key), "Now: {:?}", clock.now());
154179

155-
assert_ne!(Ok(()), lb.peek_key_n(key, nonzero!(2u32)), "Now: {:?}", clock.now());
180+
assert_ne!(
181+
Ok(()),
182+
lb.peek_key_n(key, nonzero!(2u32)),
183+
"Now: {:?}",
184+
clock.now()
185+
);
156186

157187
// should be ok again in 1s:
158188
clock.advance(ms * 1000);
159-
assert_eq!(Ok(()), lb.peek_key_n(key, nonzero!(2u32)), "Now: {:?}", clock.now());
160-
161-
assert_eq!(Ok(()), lb.check_key_n(key, nonzero!(2u32)),"Now: {:?}", clock.now());
189+
assert_eq!(
190+
Ok(()),
191+
lb.peek_key_n(key, nonzero!(2u32)),
192+
"Now: {:?}",
193+
clock.now()
194+
);
195+
196+
assert_eq!(
197+
Ok(()),
198+
lb.check_key_n(key, nonzero!(2u32)),
199+
"Now: {:?}",
200+
clock.now()
201+
);
162202
assert!(lb.peek_key_n(key, nonzero!(2u32)).is_err());
163203
}
164204
}

‎governor/tests/keyed_hashmap.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -135,7 +135,7 @@ fn reset_does_work() {
135135
assert_eq!(Ok(()), lb.check_key(key), "Now: {:?}", clock.now());
136136
clock.advance(ms);
137137
assert_eq!(Ok(()), lb.check_key(key), "Now: {:?}", clock.now());
138-
138+
139139
for _ in 0..10 {
140140
clock.advance(ms);
141141
assert_ne!(Ok(()), lb.peek_key(key), "Now: {:?}", clock.now());

‎governor/tests/middleware.rs

+2-1
Original file line numberDiff line numberDiff line change
@@ -21,7 +21,8 @@ impl RateLimitingMiddleware<<FakeRelativeClock as clock::Clock>::Instant> for My
2121
_key: &K,
2222
_limiter: impl Into<StateSnapshot>,
2323
_start_time: <FakeRelativeClock as clock::Clock>::Instant,
24-
) -> Self::NegativeOutcome {}
24+
) -> Self::NegativeOutcome {
25+
}
2526
}
2627

2728
#[test]

0 commit comments

Comments
 (0)