enforcer_synced_test.cpp

/*
 * Copyright 2021 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::SyncedEnforcer
 */

#include <casbin/casbin.h>
#include <gtest/gtest.h>

#include "config_path.h"

namespace {

std::string global_sub;
std::string global_obj;
std::string global_act;
std::string global_domain;

template <typename T>
std::shared_ptr<casbin::IEvaluator> InitializeParams(const std::string& sub, const std::string& obj, const std::string& act) {
    auto evaluator = std::make_shared<T>();
    evaluator->InitialObject("r");

    // Because of "Short String Optimization", these strings's data is in stack.
    // For MSVC compiler, when this stack frame return, these memory will can't access.
    // So we need keep this memory accessiable.
    global_sub = sub;
    global_obj = obj;
    global_act = act;

    evaluator->PushObjectString("r", "sub", global_sub);
    evaluator->PushObjectString("r", "obj", global_obj);
    evaluator->PushObjectString("r", "act", global_act);

    return evaluator;
}

template <typename T>
std::shared_ptr<casbin::IEvaluator> InitializeParamsWithoutUsers(const std::string& obj, const std::string& act) {
    auto evaluator = std::make_shared<T>();
    evaluator->InitialObject("r");

    global_obj = obj;
    global_act = act;
    evaluator->PushObjectString("r", "obj", global_obj);
    evaluator->PushObjectString("r", "act", global_act);
    return evaluator;
}

template <typename T>
std::shared_ptr<casbin::IEvaluator> InitializeParamsWithoutResources(const std::string& sub, const std::string& act) {
    auto evaluator = std::make_shared<T>();
    evaluator->InitialObject("r");

    global_sub = sub;
    global_act = act;
    evaluator->PushObjectString("r", "sub", global_sub);
    evaluator->PushObjectString("r", "act", global_act);
    return evaluator;
}

template <typename T>
std::shared_ptr<casbin::IEvaluator> InitializeParamsWithDomains(const std::string& sub, const std::string& domain, const std::string& obj, const std::string& act) {
    auto evaluator = std::make_shared<T>();
    evaluator->InitialObject("r");

    global_sub = sub;
    global_obj = obj;
    global_act = act;
    global_domain = domain;

    evaluator->PushObjectString("r", "sub", global_sub);
    evaluator->PushObjectString("r", "dom", global_domain);
    evaluator->PushObjectString("r", "obj", global_obj);
    evaluator->PushObjectString("r", "act", global_act);
    return evaluator;
}

void TestSyncFn(casbin::SyncedEnforcer& e, const std::string& sub, const std::string& obj, const std::string& act, bool control) {
    bool response = e.Enforce({sub, obj, act});
    ASSERT_EQ(response, control);
}

TEST(TestEnforcerSynced, TestSync) {
    casbin::SyncedEnforcer e(basic_model_path, basic_policy_path);

    using namespace std::literals::chrono_literals;
    auto time1 = 200ms;
    e.StartAutoLoadPolicy(time1);

    TestSyncFn(e, "alice", "data1", "read", true);
    TestSyncFn(e, "alice", "data1", "write", false);
    TestSyncFn(e, "alice", "data2", "read", false);
    TestSyncFn(e, "alice", "data2", "write", false);
    TestSyncFn(e, "bob", "data1", "read", false);
    TestSyncFn(e, "bob", "data1", "write", false);
    TestSyncFn(e, "bob", "data2", "read", false);
    TestSyncFn(e, "bob", "data2", "write", true);

    std::this_thread::sleep_for(200ms);
    e.StopAutoLoadPolicy();
}

TEST(TestEnforcerSynced, TestStopLoadPolicy) {
    casbin::SyncedEnforcer e(basic_model_path, basic_policy_path);

    using namespace std::literals::chrono_literals;
    std::chrono::duration<int64_t, std::nano> t = 5ms;

    e.StartAutoLoadPolicy(t);

    EXPECT_EQ(e.IsAutoLoadingRunning(), true);

    TestSyncFn(e, "alice", "data1", "read", true);
    TestSyncFn(e, "alice", "data1", "write", false);
    TestSyncFn(e, "alice", "data2", "read", false);
    TestSyncFn(e, "alice", "data2", "write", false);
    TestSyncFn(e, "bob", "data1", "read", false);
    TestSyncFn(e, "bob", "data1", "write", false);
    TestSyncFn(e, "bob", "data2", "read", false);
    TestSyncFn(e, "bob", "data2", "write", true);

    e.StopAutoLoadPolicy();
    std::this_thread::sleep_for(10ms);

    EXPECT_EQ(e.IsAutoLoadingRunning(), false);
}

TEST(TestEnforcerSynced, TestMultiThreadEnforce) {
    casbin::SyncedEnforcer e(basic_model_path, basic_policy_path);

    using namespace std::literals::chrono_literals;
    std::chrono::duration<int64_t, std::nano> t = 5ms;

    e.StartAutoLoadPolicy(t);

    EXPECT_EQ(e.IsAutoLoadingRunning(), true);

    for (int i = 0; i < 100; ++i) {
        std::thread t1([&] { ASSERT_EQ(e.Enforce(casbin::DataList{"alice", "data1", "read"}), true); });
        std::thread t2([&] { ASSERT_EQ(e.Enforce(casbin::DataList{"alice", "data1", "write"}), false); });
        std::thread t3([&] { ASSERT_EQ(e.Enforce(casbin::DataList{"alice", "data2", "read"}), false); });
        std::thread t4([&] { ASSERT_EQ(e.Enforce(casbin::DataList{"alice", "data2", "write"}), false); });
        std::thread t5([&] { ASSERT_EQ(e.Enforce(casbin::DataList{"bob", "data1", "read"}), false); });
        std::thread t6([&] { ASSERT_EQ(e.Enforce(casbin::DataList{"bob", "data1", "write"}), false); });
        std::thread t7([&] { ASSERT_EQ(e.Enforce(casbin::DataList{"bob", "data2", "read"}), false); });
        std::thread t8([&] { ASSERT_EQ(e.Enforce(casbin::DataList{"bob", "data2", "write"}), true); });

        t1.join();
        t2.join();
        t3.join();
        t4.join();
        t5.join();
        t6.join();
        t7.join();
        t8.join();
    }

    for (int i = 0; i < 100; ++i) {
        std::thread t1([&] { ASSERT_EQ(e.Enforce(casbin::DataVector{"alice", "data1", "read"}), true); });
        std::thread t2([&] { ASSERT_EQ(e.Enforce(casbin::DataVector{"alice", "data1", "write"}), false); });
        std::thread t3([&] { ASSERT_EQ(e.Enforce(casbin::DataVector{"alice", "data2", "read"}), false); });
        std::thread t4([&] { ASSERT_EQ(e.Enforce(casbin::DataVector{"alice", "data2", "write"}), false); });
        std::thread t5([&] { ASSERT_EQ(e.Enforce(casbin::DataVector{"bob", "data1", "read"}), false); });
        std::thread t6([&] { ASSERT_EQ(e.Enforce(casbin::DataVector{"bob", "data1", "write"}), false); });
        std::thread t7([&] { ASSERT_EQ(e.Enforce(casbin::DataVector{"bob", "data2", "read"}), false); });
        std::thread t8([&] { ASSERT_EQ(e.Enforce(casbin::DataVector{"bob", "data2", "write"}), true); });

        t1.join();
        t2.join();
        t3.join();
        t4.join();
        t5.join();
        t6.join();
        t7.join();
        t8.join();
    }

    for (int i = 0; i < 100; ++i) {
        std::thread t1([&] { ASSERT_EQ(e.Enforce(casbin::DataMap{{"sub", "alice"}, {"obj", "data1"}, {"act", "read"}}), true); });
        std::thread t2([&] { ASSERT_EQ(e.Enforce(casbin::DataMap{{"sub", "alice"}, {"obj", "data1"}, {"act", "write"}}), false); });
        std::thread t3([&] { ASSERT_EQ(e.Enforce(casbin::DataMap{{"sub", "alice"}, {"obj", "data2"}, {"act", "read"}}), false); });
        std::thread t4([&] { ASSERT_EQ(e.Enforce(casbin::DataMap{{"sub", "alice"}, {"obj", "data2"}, {"act", "write"}}), false); });
        std::thread t5([&] { ASSERT_EQ(e.Enforce(casbin::DataMap{{"sub", "bob"}, {"obj", "data1"}, {"act", "read"}}), false); });
        std::thread t6([&] { ASSERT_EQ(e.Enforce(casbin::DataMap{{"sub", "bob"}, {"obj", "data1"}, {"act", "write"}}), false); });
        std::thread t7([&] { ASSERT_EQ(e.Enforce(casbin::DataMap{{"sub", "bob"}, {"obj", "data2"}, {"act", "read"}}), false); });
        std::thread t8([&] { ASSERT_EQ(e.Enforce(casbin::DataMap{{"sub", "bob"}, {"obj", "data2"}, {"act", "write"}}), true); });

        t1.join();
        t2.join();
        t3.join();
        t4.join();
        t5.join();
        t6.join();
        t7.join();
        t8.join();
    }

    std::mutex mtx; // for evaluator
    for (int i = 0; i < 100; ++i) {
        std::thread t1([&] {
            std::shared_ptr<casbin::IEvaluator> evaluator;
            {
                std::scoped_lock lock(mtx);
                evaluator = InitializeParams<casbin::ExprtkEvaluator>("alice", "data1", "read");
            }
            ASSERT_EQ(e.Enforce(evaluator), true);
        });
        std::thread t2([&] {
            std::shared_ptr<casbin::IEvaluator> evaluator;
            {
                std::scoped_lock lock(mtx);
                evaluator = InitializeParams<casbin::ExprtkEvaluator>("alice", "data1", "write");
            }
            ASSERT_EQ(e.Enforce(evaluator), false);
        });
        std::thread t3([&] {
            std::shared_ptr<casbin::IEvaluator> evaluator;
            {
                std::scoped_lock lock(mtx);
                evaluator = InitializeParams<casbin::ExprtkEvaluator>("alice", "data2", "read");
            }
            ASSERT_EQ(e.Enforce(evaluator), false);
        });
        std::thread t4([&] {
            std::shared_ptr<casbin::IEvaluator> evaluator;
            {
                std::scoped_lock lock(mtx);
                evaluator = InitializeParams<casbin::ExprtkEvaluator>("alice", "data2", "write");
            }
            ASSERT_EQ(e.Enforce(evaluator), false);
        });
        std::thread t5([&] {
            std::shared_ptr<casbin::IEvaluator> evaluator;
            {
                std::scoped_lock lock(mtx);
                evaluator = InitializeParams<casbin::ExprtkEvaluator>("bob", "data1", "read");
            }
            ASSERT_EQ(e.Enforce(evaluator), false);
        });
        std::thread t6([&] {
            std::shared_ptr<casbin::IEvaluator> evaluator;
            {
                std::scoped_lock lock(mtx);
                evaluator = InitializeParams<casbin::ExprtkEvaluator>("bob", "data1", "write");
            }
            ASSERT_EQ(e.Enforce(evaluator), false);
        });
        std::thread t7([&] {
            std::shared_ptr<casbin::IEvaluator> evaluator;
            {
                std::scoped_lock lock(mtx);
                evaluator = InitializeParams<casbin::ExprtkEvaluator>("bob", "data2", "read");
            }
            ASSERT_EQ(e.Enforce(evaluator), false);
        });
        std::thread t8([&] {
            std::shared_ptr<casbin::IEvaluator> evaluator;
            {
                std::scoped_lock lock(mtx);
                evaluator = InitializeParams<casbin::ExprtkEvaluator>("bob", "data2", "write");
            }
            ASSERT_EQ(e.Enforce(evaluator), true);
        });

        t1.join();
        t2.join();
        t3.join();
        t4.join();
        t5.join();
        t6.join();
        t7.join();
        t8.join();
    }

    e.StopAutoLoadPolicy();
    std::this_thread::sleep_for(10ms);

    EXPECT_EQ(e.IsAutoLoadingRunning(), false);
}

TEST(TestEnforcerSynced, TestMultiThreadBatchEnforce) {
    casbin::SyncedEnforcer e(basic_model_path, basic_policy_path);

    using namespace std::literals::chrono_literals;
    std::chrono::duration<int64_t, std::nano> t = 5ms;

    e.StartAutoLoadPolicy(t);

    EXPECT_EQ(e.IsAutoLoadingRunning(), true);

    for (int i = 0; i < 100; ++i) {
        std::thread t1([&] {
            std::vector<bool> expect_result{true, false, false, false};
            ASSERT_EQ(e.BatchEnforce({{"alice", "data1", "read"}, {"alice", "data1", "write"}, {"alice", "data2", "read"}, {"alice", "data2", "write"}}), expect_result);
        });

        std::thread t2([&] {
            std::vector<bool> expect_result{false, false, false, true};
            ASSERT_EQ(e.BatchEnforce({{"bob", "data1", "read"}, {"bob", "data1", "write"}, {"bob", "data2", "read"}, {"bob", "data2", "write"}}), expect_result);
        });

        std::thread t3([&] {
            std::vector<bool> expect_result{true, false, false, false};
            ASSERT_EQ(e.BatchEnforce({{"alice", "data1", "read"}, {"alice", "data1", "write"}, {"bob", "data1", "read"}, {"bob", "data1", "write"}}), expect_result);
        });

        std::thread t4([&] {
            std::vector<bool> expect_result{false, false, false, true};
            ASSERT_EQ(e.BatchEnforce({{"alice", "data2", "read"}, {"alice", "data2", "write"}, {"bob", "data2", "read"}, {"bob", "data2", "write"}}), expect_result);
        });

        t1.join();
        t2.join();
        t3.join();
        t4.join();
    }

    e.StopAutoLoadPolicy();
    std::this_thread::sleep_for(10ms);

    EXPECT_EQ(e.IsAutoLoadingRunning(), false);
}

void testSyncedEnforcerGetPolicy(casbin::SyncedEnforcer& e, PoliciesVector expected) {
    auto myRes = e.GetPolicy();
    PoliciesVector actual;
    for (auto it = myRes.begin(); it != myRes.end(); ++it) {
        actual.push_back(*it);
    }
    std::sort(actual.begin(), actual.end());
    std::sort(expected.begin(), expected.end());
    ASSERT_EQ(expected, actual);
}

TEST(TestSyncedEnforcer, GetPolicy) {
    casbin::SyncedEnforcer e(basic_model_path, basic_policy_path);

    PoliciesVector expected_policy = {
        {"alice", "data1", "read"},
        {"bob", "data2", "write"},
    };

    testSyncedEnforcerGetPolicy(e, expected_policy);
}



} // namespace