wip

Author: estringana

appsec/src/helper/rate_limit.cpp

@@ -7,6 +7,7 @@
 #include "rate_limit.hpp"
 
 #include <chrono>
+#include <iostream>
 
 using std::chrono::duration_cast;
 using std::chrono::microseconds;
@@ -32,25 +33,42 @@ bool rate_limiter::allow()
 
     std::lock_guard<std::mutex> const lock(mtx_);
 
+    std::cout << "START\n----------\n";
     if (now_s != index_) {
+        std::cout << "New second\n";
         if (index_ == now_s - 1) {
+            std::cout << "Following second\n";
             precounter_ = counter_;
         } else {
+            std::cout << "Not following second\n";
             precounter_ = 0;
         }
         counter_ = 0;
         index_ = now_s;
+    } else {
+        std::cout << "Same second\n";
     }
 
+    std::cout << "max_per_second_ is " << max_per_second_ << std::endl;
+    ;
+    std::cout << "counter_ is " << counter_ << std::endl;
+    ;
+    std::cout << "precounter_ is " << precounter_ << std::endl;
+    ;
+    std::cout << "index_ is " << index_ << std::endl;
+    ;
+
     constexpr uint64_t mil = 1000;
     uint32_t const count =
         (precounter_ * (mil - (now_ms % mil))) / mil + counter_;
 
     if (count >= max_per_second_) {
+        std::cout << "Not allowed\n";
         return false;
     }
 
     counter_++;
+    std::cout << "Allowed\n";
 
     return true;
 }

appsec/tests/helper/rate_limit_test.cpp

@@ -47,27 +47,33 @@ class rate_limiter : public dds::rate_limiter {
 
 TEST(RateLimitTest, OnlyAllowedMaxPerSecond)
 {
+    auto first_round_time = system_clock::now();
+    auto second_round_time = first_round_time + std::chrono::seconds(5);
+
+    std::cout << "first_round_time is " << first_round_time.time_since_epoch().count() << std::endl;
+    std::cout << "second_round_time is " << second_round_time.time_since_epoch().count() << std::endl;
+
     std::unique_ptr<mock::timer> timer = std::make_unique<mock::timer>();
     // Four calls within the same second
-    timer->responses.push(system_clock::duration(1708963615));
+    timer->responses.push(first_round_time.time_since_epoch());
 
     mock::rate_limiter rate_limiter(2);
     rate_limiter.set_timer(std::move(timer));
 
     int allowed = 0;
-    for (int i = 0; i < 100; i++) {
+    for (int i = 0; i < 10; i++) {
         if (rate_limiter.allow()) {
             allowed++;
         }
     }
     EXPECT_EQ(2, allowed);
 
     timer = std::make_unique<mock::timer>();
-    timer->responses.push(system_clock::duration(1709963630));
+    timer->responses.push(second_round_time.time_since_epoch());
     rate_limiter.set_timer(std::move(timer));
 
     allowed = 0;
-    for (int i = 0; i < 100; i++) {
+    for (int i = 0; i < 10; i++) {
         if (rate_limiter.allow()) {
             allowed++;
         }