stlye: Move function loadPolicyLine to Adapter and adjust the paramet…

…er of assert

Signed-off-by: Edmond <edomondja@gmail.com>

src/persist/Adapter.lua

@@ -13,8 +13,48 @@
 --limitations under the License.
 
 --Adapter is the interface for Casbin adapters.
+local Util = require("src.util.Util")
 local Adapter = {}
 Adapter.__index = Adapter
+
+function Adapter.loadPolicyLine(line, model)
+    -- Loads a text line as a policy rule to model.
+
+    if line == "" then
+        return
+    end
+
+    if line:sub(1,1) == "#" then
+        return
+    end
+
+    local tokens = Util.split(line, ",")
+    local key = tokens[1]
+    local sec = key:sub(1,1)
+
+    if model.model[sec] == nil then
+        return
+    end
+    if model.model[sec][key] == nil then
+        return
+    end
+
+    model.model[sec][key].policy = model.model[sec][key].policy or {}
+    model.model[sec][key].policyMap={}
+    for i,policy in pairs(model.model[sec][key].policy) do
+        model.model[sec][key].policyMap[table.concat(policy,",")]=i
+    end
+    local rules = {}
+    for i = 2, #tokens do
+        table.insert(rules, tokens[i])
+    end
+    table.insert(model.model[sec][key].policy, rules)
+    model.model[sec][key].policyMap={}
+    for i,policy in pairs(model.model[sec][key].policy) do
+        model.model[sec][key].policyMap[table.concat(policy,",")]=i
+    end
+end
+
 --[[
         * loadPolicy loads all policy rules from the storage.
         *

src/persist/file_adapter/FileAdapter.lua

@@ -45,7 +45,8 @@ function FileAdapter:loadPolicy(model)
 
     if f then
         for line in f:lines() do
-            Util.loadPolicyLine(line, model)
+            line = Util.trim(line)
+            Adapter.loadPolicyLine(line, model)
         end
     end
 

src/persist/file_adapter/FilteredAdapter.lua

@@ -72,7 +72,7 @@ function FilteredAdapter:loadFilteredPolicyFile(model, filter)
         for line in f:lines() do
             line = Util.trim(line)
             if self:filterLine(line, filter) == false then
-                Util.loadPolicyLine(line, model)
+                Adapter.loadPolicyLine(line, model)
             end
         end
     end

src/util/Util.lua

@@ -247,43 +247,4 @@ function Util.printTable(t)
     return s
 end
 
-function Util.loadPolicyLine(line, model)
-    -- Loads a text line as a policy rule to model.
-
-    if line == "" then
-        return
-    end
-
-    if line:sub(1,1) == "#" then
-        return
-    end
-
-    local tokens = Util.split(line, ",")
-    local key = tokens[1]
-    local sec = key:sub(1,1)
-
-    if model.model[sec] == nil then
-        return
-    end
-    if model.model[sec][key] == nil then
-        return
-    end
-
-    model.model[sec][key].policy = model.model[sec][key].policy or {}
-    model.model[sec][key].policyMap={}
-    for i,policy in pairs(model.model[sec][key].policy) do
-        model.model[sec][key].policyMap[table.concat(policy,",")]=i
-    end
-    local rules = {}
-    for i = 2, #tokens do
-        table.insert(rules, tokens[i])
-    end
-    table.insert(model.model[sec][key].policy, rules)
-    model.model[sec][key].policyMap={}
-    for i,policy in pairs(model.model[sec][key].policy) do
-        model.model[sec][key].policyMap[table.concat(policy,",")]=i
-    end
-end
-
-
 return Util

tests/config/config_spec.lua

@@ -20,43 +20,43 @@ local config = Config:newConfig(path)
 describe("config tests", function()
 
     it("test default::key", function()
-        assert.are.equals(config:get("debug"), "true")
-        assert.are.equals(config:get("url"), "act.wiki")
+        assert.are.equals("true", config:get("debug"))
+        assert.are.equals("act.wiki", config:get("url"))
     end)
 
     it("test redis::key", function()
-        assert.are.equals(config:get("redis::redis.key"), "push1,push2")
-        assert.are.equals(config:get("mysql::mysql.dev.host"), "127.0.0.1")
-        assert.are.equals(config:get("mysql::mysql.master.host"), "10.0.0.1")
+        assert.are.equals("push1,push2", config:get("redis::redis.key"))
+        assert.are.equals("127.0.0.1", config:get("mysql::mysql.dev.host"))
+        assert.are.equals("10.0.0.1", config:get("mysql::mysql.master.host"))
     end)
 
     it("test math::key", function()
-        assert.are.equals(config:get("math::math.i64"), "64")
-        assert.are.equals(config:get("math::math.f64"), "64.1")
+        assert.are.equals("64", config:get("math::math.i64"))
+        assert.are.equals("64.1", config:get("math::math.f64"))
     end)
 
     it("test other::key", function()
-        assert.are.equals(config:get("other::name"), "ATC自动化测试^-^&($#……#")
-        assert.are.equals(config:get("other::key1"), "test key")
+        assert.are.equals("ATC自动化测试^-^&($#……#", config:get("other::name"))
+        assert.are.equals("test key",config:get("other::key1"))
     end)
 
     it("test set", function()
         config:set("other::key1", "new test key")
-        assert.are.equals(config:get("other::key1"), "new test key")
+        assert.are.equals("new test key",config:get("other::key1"))
         config:set("other::key1", "test key")
     end)
 
     it("test multi line", function()
-        assert.are.equals(config:get("multi1::name"), "r.sub==p.sub && r.obj==p.obj")
-        assert.are.equals(config:get("multi2::name"), "r.sub==p.sub && r.obj==p.obj")
-        assert.are.equals(config:get("multi3::name"), "r.sub==p.sub && r.obj==p.obj")
-        assert.are.equals(config:get("multi4::name"), "")
-        assert.are.equals(config:get("multi5::name"), "r.sub==p.sub && r.obj==p.obj")
+        assert.are.equals("r.sub==p.sub && r.obj==p.obj", config:get("multi1::name"))
+        assert.are.equals("r.sub==p.sub && r.obj==p.obj", config:get("multi2::name"))
+        assert.are.equals("r.sub==p.sub && r.obj==p.obj", config:get("multi3::name"))
+        assert.are.equals("", config:get("multi4::name"))
+        assert.are.equals("r.sub==p.sub && r.obj==p.obj", config:get("multi5::name"))
     end)
 
     it("test get{type}", function()
-        assert.are.equals(config:getString("multi5::name"), "r.sub==p.sub && r.obj==p.obj")
-        assert.are.same(config:getStrings("multi5::name"), {"r.sub==p.sub && r.obj==p.obj"})
+        assert.are.equals("r.sub==p.sub && r.obj==p.obj", config:getString("multi5::name"))
+        assert.are.same({"r.sub==p.sub && r.obj==p.obj"}, config:getStrings("multi5::name"))
         assert.has_error(function () config:getBool("multi5::name") end, "Not a boolean value")
         assert.has_error(function () config:getNum("multi5::name") end, "Not a num value")
     end)

tests/main/enforcer_spec.lua

@@ -404,7 +404,7 @@ describe("Enforcer tests", function ()
             {"bob", "data2", "write"}
         }
 
-        assert.is.Same(e:BatchEnforce(requests), res)
+        assert.is.Same(res, e:BatchEnforce(requests))
     end)
 
     it("enforceEx test", function ()
@@ -419,40 +419,40 @@ describe("Enforcer tests", function ()
 
         local e = Enforcer:new(model, policy)
 
-        assert.is.Same(test(e, "alice", "data1", "read"), {"alice", "data1", "read"})
-        assert.is.Same(test(e, "alice", "data1", "write"), {})
-        assert.is.Same(test(e, "alice", "data2", "read"), {})
-        assert.is.Same(test(e, "alice", "data2", "write"), {})
-        assert.is.Same(test(e, "bob", "data1", "read"), {})
-        assert.is.Same(test(e, "bob", "data1", "write"), {})
-        assert.is.Same(test(e, "bob", "data2", "read"), {})
-        assert.is.Same(test(e, "bob", "data2", "write"), {"bob", "data2", "write"})
+        assert.is.Same({"alice", "data1", "read"}, test(e, "alice", "data1", "read"))
+        assert.is.Same({}, test(e, "alice", "data1", "write"))
+        assert.is.Same({}, test(e, "alice", "data2", "read"))
+        assert.is.Same({}, test(e, "alice", "data2", "write"))
+        assert.is.Same({}, test(e, "bob", "data1", "read"))
+        assert.is.Same({}, test(e, "bob", "data1", "write"))
+        assert.is.Same({}, test(e, "bob", "data2", "read"))
+        assert.is.Same({"bob", "data2", "write"}, test(e, "bob", "data2", "write"))
 
         model  = path .. "/examples/rbac_model.conf"
         policy  = path .. "/examples/rbac_policy.csv"
 
         e = Enforcer:new(model, policy)
 
-        assert.is.Same(test(e, "alice", "data1", "read"), {"alice", "data1", "read"})
-        assert.is.Same(test(e, "alice", "data1", "write"), {})
-        assert.is.Same(test(e, "alice", "data2", "read"), {"data2_admin", "data2", "read"})
-        assert.is.Same(test(e, "alice", "data2", "write"), {"data2_admin", "data2", "write"})
-        assert.is.Same(test(e, "bob", "data1", "read"), {})
-        assert.is.Same(test(e, "bob", "data1", "write"), {})
-        assert.is.Same(test(e, "bob", "data2", "read"), {})
-        assert.is.Same(test(e, "bob", "data2", "write"), {"bob", "data2", "write"})
+        assert.is.Same({"alice", "data1", "read"}, test(e, "alice", "data1", "read"))
+        assert.is.Same({}, test(e, "alice", "data1", "write"))
+        assert.is.Same({"data2_admin", "data2", "read"}, test(e, "alice", "data2", "read"))
+        assert.is.Same({"data2_admin", "data2", "write"}, test(e, "alice", "data2", "write"))
+        assert.is.Same({}, test(e, "bob", "data1", "read"))
+        assert.is.Same({}, test(e, "bob", "data1", "write"))
+        assert.is.Same({}, test(e, "bob", "data2", "read"))
+        assert.is.Same({"bob", "data2", "write"}, test(e, "bob", "data2", "write"))
 
         model  = path .. "/examples/priority_model.conf"
         policy  = path .. "/examples/priority_policy.csv"
 
         e = Enforcer:new(model, policy)
 
-        assert.is.Same(test(e, "alice", "data1", "read"), {"alice", "data1", "read", "allow"})
-        assert.is.Same(test(e, "alice", "data1", "write"), {"data1_deny_group", "data1", "write", "deny"})
-        assert.is.Same(test(e, "alice", "data2", "read"), {})
-        assert.is.Same(test(e, "alice", "data2", "write"), {})
-        assert.is.Same(test(e, "bob", "data1", "write"), {})
-        assert.is.Same(test(e, "bob", "data2", "read"), {"data2_allow_group", "data2", "read", "allow"})
-        assert.is.Same(test(e, "bob", "data2", "write"), {"bob", "data2", "write", "deny"})
+        assert.is.Same({"alice", "data1", "read", "allow"}, test(e, "alice", "data1", "read"))
+        assert.is.Same({"data1_deny_group", "data1", "write", "deny"}, test(e, "alice", "data1", "write"))
+        assert.is.Same({}, test(e, "alice", "data2", "read"))
+        assert.is.Same({}, test(e, "alice", "data2", "write"))
+        assert.is.Same({}, test(e, "bob", "data1", "write"))
+        assert.is.Same({"data2_allow_group", "data2", "read", "allow"}, test(e, "bob", "data2", "read"))
+        assert.is.Same({"bob", "data2", "write", "deny"}, test(e, "bob", "data2", "write"))
     end)
 end)

tests/main/management_api_spec.lua

@@ -23,15 +23,15 @@ describe("Management API tests", function ()
 
         local e = Enforcer:new(model, policy)
 
-        assert.is.Same(e:GetAllSubjects(), {"alice", "bob", "data2_admin"})
-        assert.is.Same(e:GetAllObjects(), {"data1", "data2"})
-        assert.is.Same(e:GetAllActions(), {"read", "write"})
-        assert.is.Same(e:GetAllRoles(), {"data2_admin"})
-
-        assert.is.Same(e:GetAllNamedSubjects("p"), {"alice", "bob", "data2_admin"})
-        assert.is.Same(e:GetAllNamedObjects("p"), {"data1", "data2"})
-        assert.is.Same(e:GetAllNamedActions("p"), {"read", "write"})
-        assert.is.Same(e:GetAllNamedRoles("g"), {"data2_admin"})
+        assert.is.Same({"alice", "bob", "data2_admin"}, e:GetAllSubjects())
+        assert.is.Same({"data1", "data2"}, e:GetAllObjects())
+        assert.is.Same({"read", "write"}, e:GetAllActions())
+        assert.is.Same({"data2_admin"}, e:GetAllRoles())
+
+        assert.is.Same({"alice", "bob", "data2_admin"}, e:GetAllNamedSubjects("p"))
+        assert.is.Same({"data1", "data2"}, e:GetAllNamedObjects("p"))
+        assert.is.Same({"read", "write"}, e:GetAllNamedActions("p"))
+        assert.is.Same({"data2_admin"}, e:GetAllNamedRoles("g"))
     end)
 
     it("Get Policy test", function ()
@@ -57,15 +57,15 @@ describe("Management API tests", function ()
         local res = {
             {"bob", "data2", "write"}
         }
-        assert.is.Same(e:GetFilteredPolicy(0, "bob"), res)
+        assert.is.Same(res, e:GetFilteredPolicy(0, "bob"))
 
         res = {
             {"bob", "data2", "write"},
             {"data2_admin", "data2", "read"},
             {"data2_admin", "data2", "write"}
         }
 
-        assert.is.Same(e:GetFilteredPolicy(1, "data2"), res)
+        assert.is.Same(res, e:GetFilteredPolicy(1, "data2"))
     end)
 
     it("Get Grouping Policy test", function ()
@@ -78,7 +78,7 @@ describe("Management API tests", function ()
             {"alice", "data2_admin"}
         }
 
-        assert.is.Same(e:GetGroupingPolicy(), res)
+        assert.is.Same(res, e:GetGroupingPolicy())
     end)
 
     it("Get Filtered Grouping Policy test", function ()
@@ -91,7 +91,7 @@ describe("Management API tests", function ()
             {"alice", "data2_admin"}
         }
 
-        assert.is.Same(e:GetFilteredGroupingPolicy(0, "alice"), res)
+        assert.is.Same(res, e:GetFilteredGroupingPolicy(0, "alice"))
     end)
 
     it("Has Policy test", function ()
@@ -128,7 +128,7 @@ describe("Management API tests", function ()
 		    {"data2_admin", "data2", "write"}
         }
 
-        assert.is.Same(e:GetPolicy(), res)
+        assert.is.Same(res, e:GetPolicy())
 
         e:RemovePolicy("alice", "data1", "read")
 	    e:RemovePolicy("bob", "data2", "write")
@@ -160,7 +160,7 @@ describe("Management API tests", function ()
             {"ham", "data4", "write"}
         }
 
-        assert.is.Same(e:GetPolicy(), res)
+        assert.is.Same(res, e:GetPolicy())
 
         e:RemovePolicies(rules)
         e:RemovePolicies(rules)
@@ -175,13 +175,13 @@ describe("Management API tests", function ()
             {"eve", "data3", "read"}
         }
 
-        assert.is.Same(e:GetPolicy(), res)
+        assert.is.Same(res, e:GetPolicy())
 
         e:RemoveFilteredPolicy(1, "data2")
-        assert.is.Same(e:GetPolicy(), {{"eve", "data3", "read"}})
+        assert.is.Same({{"eve", "data3", "read"}}, e:GetPolicy())
 
         e:UpdatePolicy({"eve", "data3", "read"}, {"eve", "data3", "write"})
-        assert.is.Same(e:GetPolicy(), {{"eve", "data3", "write"}})
+        assert.is.Same({{"eve", "data3", "write"}}, e:GetPolicy())
 
         e:AddPolicies(rules)
         e:RemovePolicies({{"eve", "data3", "write"}, {"leyo", "data4", "read"}, {"katy", "data4", "write"}})
@@ -205,14 +205,14 @@ describe("Management API tests", function ()
         local res = {
             {"alice", "data2_admin"}
         }
-        assert.is.Same(e:GetGroupingPolicy(), res)
+        assert.is.Same(res, e:GetGroupingPolicy())
 
         e:AddGroupingPolicy("bob", "data2_admin")
         res = {
             {"alice", "data2_admin"},
             {"bob", "data2_admin"}
         }
-        assert.is.Same(e:GetGroupingPolicy(), res)
+        assert.is.Same(res, e:GetGroupingPolicy())
 
         e:RemoveGroupingPolicy("bob", "data2_admin")
 
@@ -228,13 +228,13 @@ describe("Management API tests", function ()
             {"cathy", "data2_admin"},
             {"eve", "data2_admin"}
         }
-        assert.is.Same(e:GetGroupingPolicy(), res)
+        assert.is.Same(res, e:GetGroupingPolicy())
 
         e:RemoveGroupingPolicies(rules)
-        assert.is.Same(e:GetGroupingPolicy(), {{"alice", "data2_admin"}})
+        assert.is.Same({{"alice", "data2_admin"}}, e:GetGroupingPolicy())
 
         e:UpdateGroupingPolicy({"alice", "data2_admin"}, {"bob", "data2_admin"})
-        assert.is.Same(e:GetGroupingPolicy(), {{"bob", "data2_admin"}})
+        assert.is.Same({{"bob", "data2_admin"}}, e:GetGroupingPolicy())
 
         e:UpdateGroupingPolicy({"bob", "data2_admin"}, {"alice", "data2_admin"})
 
@@ -250,14 +250,14 @@ describe("Management API tests", function ()
             {"alice", "data1_admin"},
             {"bob", "data1_admin"},
         }
-        assert.is.Same(e:GetFilteredGroupingPolicy(1, "data1_admin"), res)
+        assert.is.Same(res, e:GetFilteredGroupingPolicy(1, "data1_admin"))
 
         e:RemoveFilteredGroupingPolicy(1, "data1_admin")
 
         res = {
             {"alice", "data2_admin"},
             {"eve", "data2_admin"}
         }
-        assert.is.Same(e:GetGroupingPolicy(), res)
+        assert.is.Same(res, e:GetGroupingPolicy())
     end)
 end)