feat: support load policy from text (#372)

* feat: support load policy from text Signed-off-by: Taoyuesong <[email protected]> * feat: add text adapter Signed-off-by: Taoyuesong <[email protected]> * feat: clean up test project Signed-off-by: Taoyuesong <[email protected]> * fix: remove not used set equal Signed-off-by: Taoyuesong <[email protected]> --------- Signed-off-by: Taoyuesong <[email protected]>
casbin · Oct 29, 2024 · 85b9330 · 85b9330
1 parent 0b477c0
commit 85b9330
Show file tree

Hide file tree

Showing 35 changed files with 1,871 additions and 2,163 deletions.
diff --git a/Casbin.UnitTests/GenericTests/SupportCountTest.cs b/Casbin.UnitTests/GenericTests/SupportCountTest.cs
@@ -37,85 +37,81 @@ private static void TestEnforce(IEnforcer enforcer, EnforceContext context, int
         {
             case 1:
                 Assert.True(enforcer.Enforce(context, "value1"));
-                Assert.True(enforcer.Enforce(context, new[] { "value1" }));
+                Assert.True(enforcer.Enforce(context, ["value1"]));
                 break;
             case 2:
                 Assert.True(enforcer.Enforce(context, "value1", "value2"));
-                Assert.True(enforcer.Enforce(context, new[] { "value1", "value2" }));
+                Assert.True(enforcer.Enforce(context, ["value1", "value2"]));
                 break;
             case 3:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3"));
-                Assert.True(enforcer.Enforce(context, new[] { "value1", "value2", "value3" }));
+                Assert.True(enforcer.Enforce(context, ["value1", "value2", "value3"]));
                 break;
             case 4:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3",
                     "value4"));
-                Assert.True(enforcer.Enforce(context, new[] { "value1", "value2", "value3", "value4" }));
+                Assert.True(enforcer.Enforce(context, ["value1", "value2", "value3", "value4"]));
                 break;
             case 5:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3",
                     "value4", "value5"));
-                Assert.True(enforcer.Enforce(context, new[] { "value1", "value2", "value3", "value4", "value5" }));
+                Assert.True(enforcer.Enforce(context, ["value1", "value2", "value3", "value4", "value5"]));
                 break;
             case 6:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3",
                     "value4", "value5", "value6"));
                 Assert.True(enforcer.Enforce(context,
-                    new[] { "value1", "value2", "value3", "value4", "value5", "value6" }));
+                    ["value1", "value2", "value3", "value4", "value5", "value6"]));
                 break;
             case 7:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3",
                     "value4", "value5", "value6", "value7"));
                 Assert.True(enforcer.Enforce(context,
-                    new[] { "value1", "value2", "value3", "value4", "value5", "value6", "value7" }));
+                    ["value1", "value2", "value3", "value4", "value5", "value6", "value7"]));
                 break;
             case 8:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3",
                     "value4", "value5", "value6", "value7", "value8"));
                 Assert.True(enforcer.Enforce(context,
-                    new[] { "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8" }));
+                    ["value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8"]));
                 break;
             case 9:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3",
                     "value4", "value5", "value6", "value7", "value8", "value9"));
                 Assert.True(enforcer.Enforce(context,
-                    new[]
-                    {
-                        "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8", "value9"
-                    }));
+                [
+                    "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8", "value9"
+                ]));
                 break;
             case 10:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3",
                     "value4", "value5", "value6", "value7", "value8", "value9",
                     "value10"));
                 Assert.True(enforcer.Enforce(context,
-                    new[]
-                    {
-                        "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8", "value9",
+                [
+                    "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8", "value9",
                         "value10"
-                    }));
+                ]));
                 break;
             case 11:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3",
                     "value4", "value5", "value6", "value7", "value8", "value9",
                     "value10", "value11"));
                 Assert.True(enforcer.Enforce(context,
-                    new[]
-                    {
-                        "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8", "value9",
+                [
+                    "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8", "value9",
                         "value10", "value11"
-                    }));
+                ]));
                 break;
             case 12:
                 Assert.True(enforcer.Enforce(context, "value1", "value2", "value3",
                     "value4", "value5", "value6", "value7", "value8", "value9",
                     "value10", "value11", "value12"));
                 Assert.True(enforcer.Enforce(context,
-                    new[]
-                    {
-                        "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8", "value9",
+                [
+                    "value1", "value2", "value3", "value4", "value5", "value6", "value7", "value8", "value9",
                         "value10", "value11", "value12"
-                    }));
+                ]));
                 break;
             case 13:
                 Assert.True(enforcer.Enforce(context, Request.CreateValues("value1", "value2", "value3",
@@ -131,7 +127,7 @@ private static void TestEnforce(IEnforcer enforcer, EnforceContext context, int
 
     private static IPolicyValues CreateTestPolicy(int count)
     {
-        List<string> policy = new();
+        List<string> policy = [];
         for (int i = 0; i < count; i++)
         {
             policy.Add($"value{i + 1}");

diff --git a/Casbin.UnitTests/Mock/MockRoleManager.cs b/Casbin.UnitTests/Mock/MockRoleManager.cs
@@ -14,7 +14,7 @@ public class MockCustomRoleManager : IRoleManager
 
     public IEnumerable<string> GetRoles(string name, string domain = null) => null;
     public IEnumerable<string> GetUsers(string name, string domain = null) => null;
-    public IEnumerable<string> GetDomains(string name) => Enumerable.Empty<string>();
+    public IEnumerable<string> GetDomains(string name) => [];
 
     public bool HasLink(string name1, string name2, string domain = null)
     {

diff --git a/Casbin.UnitTests/Mock/TestRescource.cs b/Casbin.UnitTests/Mock/TestRescource.cs
@@ -0,0 +1,14 @@
+namespace Casbin.UnitTests.Mock;
+
+public class TestResource
+{
+    public TestResource(string name, string owner)
+    {
+        Name = name;
+        Owner = owner;
+    }
+
+    public string Name { get; }
+
+    public string Owner { get; }
+}
diff --git a/Casbin.UnitTests/Mock/TestSubject.cs b/Casbin.UnitTests/Mock/TestSubject.cs
@@ -0,0 +1,14 @@
+namespace Casbin.UnitTests.Mock;
+
+public class TestSubject
+{
+    public TestSubject(string name, int age)
+    {
+        Name = name;
+        Age = age;
+    }
+
+    public string Name { get; }
+
+    public int Age { get; }
+}
diff --git a/Casbin.UnitTests/ModelTests/CachedEnforcerTest.cs b/Casbin.UnitTests/ModelTests/CachedEnforcerTest.cs
@@ -2,20 +2,19 @@
 using Casbin.UnitTests.Mock;
 using Xunit;
 using Xunit.Abstractions;
-using static Casbin.UnitTests.Util.TestUtil;
 
 namespace Casbin.UnitTests.ModelTests;
 
 [Collection("Model collection")]
 public class CachedEnforcerTest
 {
-    private readonly TestModelFixture TestModelFixture;
+    private readonly TestModelFixture _testModelFixture;
     private readonly ITestOutputHelper _testOutputHelper;
 
     public CachedEnforcerTest(ITestOutputHelper testOutputHelper, TestModelFixture testModelFixture)
     {
         _testOutputHelper = testOutputHelper;
-        TestModelFixture = testModelFixture;
+        _testModelFixture = testModelFixture;
     }
 
     [Fact]
@@ -32,28 +31,28 @@ public void TestEnforceWithCache()
         e.EnableCache(true);
         e.EnableAutoCleanEnforceCache(false);
 
-        TestEnforce(e, "alice", "data1", "read", true);
-        TestEnforce(e, "alice", "data1", "write", false);
-        TestEnforce(e, "alice", "data2", "read", false);
-        TestEnforce(e, "alice", "data2", "write", false);
+        Assert.True(e.Enforce("alice", "data1", "read"));
+        Assert.False(e.Enforce("alice", "data1", "write"));
+        Assert.False(e.Enforce("alice", "data2", "read"));
+        Assert.False(e.Enforce("alice", "data2", "write"));
 
         // 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");
 
-        TestEnforce(e, "alice", "data1", "read", true);
-        TestEnforce(e, "alice", "data1", "write", false);
-        TestEnforce(e, "alice", "data2", "read", false);
-        TestEnforce(e, "alice", "data2", "write", false);
+        Assert.True(e.Enforce("alice", "data1", "read"));
+        Assert.False(e.Enforce("alice", "data1", "write"));
+        Assert.False(e.Enforce("alice", "data2", "read"));
+        Assert.False(e.Enforce("alice", "data2", "write"));
 
         // 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.EnforceCache.Clear();
 
-        TestEnforce(e, "alice", "data1", "read", false);
-        TestEnforce(e, "alice", "data1", "write", false);
-        TestEnforce(e, "alice", "data2", "read", false);
-        TestEnforce(e, "alice", "data2", "write", false);
+        Assert.False(e.Enforce("alice", "data1", "read"));
+        Assert.False(e.Enforce("alice", "data1", "write"));
+        Assert.False(e.Enforce("alice", "data2", "read"));
+        Assert.False(e.Enforce("alice", "data2", "write"));
     }
 
     [Fact]
@@ -69,18 +68,18 @@ public void TestAutoCleanCache()
 #endif
         e.EnableCache(true);
 
-        TestEnforce(e, "alice", "data1", "read", true);
-        TestEnforce(e, "alice", "data1", "write", false);
-        TestEnforce(e, "alice", "data2", "read", false);
-        TestEnforce(e, "alice", "data2", "write", false);
+        Assert.True(e.Enforce("alice", "data1", "read"));
+        Assert.False(e.Enforce("alice", "data1", "write"));
+        Assert.False(e.Enforce("alice", "data2", "read"));
+        Assert.False(e.Enforce("alice", "data2", "write"));
 
         // 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");
 
-        TestEnforce(e, "alice", "data1", "read", false);
-        TestEnforce(e, "alice", "data1", "write", false);
-        TestEnforce(e, "alice", "data2", "read", false);
-        TestEnforce(e, "alice", "data2", "write", false);
+        Assert.False(e.Enforce("alice", "data1", "read"));
+        Assert.False(e.Enforce("alice", "data1", "write"));
+        Assert.False(e.Enforce("alice", "data2", "read"));
+        Assert.False(e.Enforce("alice", "data2", "write"));
     }
 }