test: Added Enforcer tests

Signed-off-by: Yash Pandey (YP) <[email protected]>

Author: EmperorYP7

casbin/CMakeLists.txt

@@ -1,4 +1,16 @@
-set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)
+#  Copyright 2020 The casbin Authors. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
 
 FILE(GLOB_RECURSE SRC_FILES "*.cpp" "*.h")
 
@@ -20,3 +32,9 @@ install(
     TARGETS casbin
     DESTINATION lib
 )
+
+install(
+    DIRECTORY ${CMAKE_SOURCE_DIR}/casbin
+    DESTINATION ${CMAKE_SOURCE_DIR}/lib
+    FILES_MATCHING PATTERN "*.h"
+)

casbin/enforcer_synced.cpp

@@ -110,7 +110,7 @@ void SyncedEnforcer ::StartAutoLoadPolicy(std::chrono::duration<int64_t, std::na
         SyncedEnforcer::LoadPolicy();
         ++n;
     };
-    ticker = std::unique_ptr<Ticker>(new Ticker(onTick, t));
+    ticker = std::make_unique<Ticker>(onTick, t);
     n = 1;
     ticker->start();
 }

casbin/util/ticker.h

@@ -44,7 +44,7 @@ class Ticker {
     void timer_loop();
     on_tick_t           _onTick;
     tick_interval_t     _tickInterval;
-    std::atomic_bool _running;
+    std::atomic_bool    _running;
     std::mutex          _tickIntervalMutex;
     future_vec          _futures1;
     future_vec          _futures2;

tests/CMakeLists.txt

@@ -12,10 +12,13 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+set(CMAKE_CXX_STANDARD 17)
+
 add_executable(
   casbintest
-  test_enforcer.cpp
-  main.cpp
+  enforcer_test.cpp
+  enforcer_cached_test.cpp
+  enforcer_synced_test.cpp
 )
 
 target_include_directories(casbintest PUBLIC ${CMAKE_SOURCE_DIR})

tests/enforcer_cached_test.cpp

@@ -0,0 +1,46 @@
+/*
+* Copyright 2020 The casbin Authors. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* This is a test file showcasing the workflow of casbin::CachedEnforcer
+*/
+
+#include <gtest/gtest.h>
+#include <casbin/casbin.h>
+
+TEST(TestEnforcerCached, TestCache) {
+    std::string model = "../../examples/basic_model.conf";
+    std::string policy = "../../examples/basic_policy.csv";
+    casbin::CachedEnforcer e(model, policy);
+    ASSERT_EQ(e.Enforce({ "alice", "data1", "read" }), true);
+    ASSERT_EQ(e.Enforce({ "alice", "data1", "write" }), false);
+    ASSERT_EQ(e.Enforce({ "alice", "data2", "read" }), false);
+    ASSERT_EQ(e.Enforce({ "alice", "data2", "write" }), false);
+
+    // The cache is enabled, so even if we remove a policy rule, the decision
+    // for ("alice", "data1", "read") will still be true, as it uses the cached result.
+    e.RemovePolicy({ "alice", "data1", "read" });
+    ASSERT_EQ(e.Enforce({ "alice", "data1", "read" }), true);
+    ASSERT_EQ(e.Enforce({ "alice", "data1", "write" }), false);
+    ASSERT_EQ(e.Enforce({ "alice", "data2", "read" }), false);
+    ASSERT_EQ(e.Enforce({ "alice", "data2", "write" }), false);
+
+    // Now we invalidate the cache, then all first-coming Enforce() has to be evaluated in real-time.
+    // The decision for ("alice", "data1", "read") will be false now.
+    e.InvalidateCache();
+    ASSERT_EQ(e.Enforce({ "alice", "data1", "read" }), false);
+    ASSERT_EQ(e.Enforce({ "alice", "data1", "write" }), false);
+    ASSERT_EQ(e.Enforce({ "alice", "data2", "read" }), false);
+    ASSERT_EQ(e.Enforce({ "alice", "data2", "write" }), false);
+}

tests/enforcer_synced_test.cpp

@@ -0,0 +1,68 @@
+/*
+* Copyright 2020 The casbin Authors. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+* This is a test file showcasing the workflow of casbin::CachedEnforcer
+*/
+
+#include <gtest/gtest.h>
+#include <casbin/casbin.h>
+
+// TEST(TestEnforcerSynced, TestSync) {
+//     std::string model = "../../examples/basic_model.conf";
+//     std::string policy = "../../examples/basic_policy.csv";
+//     casbin::SyncedEnforcer e(model, policy);
+
+//     using namespace std::literals::chrono_literals;
+//     auto time1 = 200ms;
+//     e.StartAutoLoadPolicy(time1);
+
+//     EXPECT_TRUE(e.Enforce({ "alice", "data1", "read" }));
+//     EXPECT_FALSE(e.Enforce({ "alice", "data1", "write" }));
+//     EXPECT_FALSE(e.Enforce({ "alice", "data2", "read" }));
+//     EXPECT_FALSE(e.Enforce({ "alice", "data2", "write" }));
+//     EXPECT_FALSE(e.Enforce({ "bob", "data1", "read" }));
+//     EXPECT_FALSE(e.Enforce({ "bob", "data1", "write" }));
+//     EXPECT_FALSE(e.Enforce({ "bob", "data2", "read" }));
+//     EXPECT_TRUE(e.Enforce({ "bob", "data2", "write" }));
+
+//     e.StopAutoLoadPolicy();
+// }
+
+// TEST(TestEnforcerSynced, TestStopLoadPolicy) {
+//     std::string model = "../../examples/basic_model.conf";
+//     std::string policy = "../../examples/basic_policy.csv";
+//     casbin::SyncedEnforcer e(model, policy);
+
+//     using namespace std::literals::chrono_literals;
+//     std::chrono::duration<int64_t, std::nano> t = 5ms;
+
+//     e.StartAutoLoadPolicy(t);
+
+//     EXPECT_EQ(e.IsAutoLoadingRunning(), true);
+
+//     ASSERT_EQ(e.Enforce({ "alice", "data1", "read" }), true);
+//     ASSERT_EQ(e.Enforce({ "alice", "data1", "write" }), false);
+//     ASSERT_EQ(e.Enforce({ "alice", "data2", "read" }), false);
+//     ASSERT_EQ(e.Enforce({ "alice", "data2", "write" }), false);
+//     ASSERT_EQ(e.Enforce({ "bob", "data1", "read" }), false);
+//     ASSERT_EQ(e.Enforce({ "bob", "data1", "write" }), false);
+//     ASSERT_EQ(e.Enforce({ "bob", "data2", "read" }), false);
+//     ASSERT_EQ(e.Enforce({ "bob", "data2", "write" }), true);
+
+//     e.StopAutoLoadPolicy();
+//     std::this_thread::sleep_for(10ms);
+
+//     EXPECT_EQ(e.IsAutoLoadingRunning(), false);
+// }