diff --git a/MainProject.Tests/Services/PermissionService_Tests.cs b/MainProject.Tests/Services/PermissionService_Tests.cs
new file mode 100644
index 0000000..70885bb
--- /dev/null
+++ b/MainProject.Tests/Services/PermissionService_Tests.cs
@@ -0,0 +1,377 @@
+using BasicDotnetTemplate.MainProject.Services;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.User;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using Newtonsoft.Json;
+
+
+
+namespace BasicDotnetTemplate.MainProject.Tests;
+
+[TestClass]
+public class PermissionService_Tests
+{
+    private static PermissionService _permissionService = TestUtils.CreatePermissionService();
+    private static string _name = "TEST";
+    private static PermissionSystem _permissionSystem = new PermissionSystem()
+    {
+        Name = _name,
+        Enabled = false
+    };
+
+    [TestMethod]
+    public void Inizialize()
+    {
+        try
+        {
+            var permissionService = TestUtils.CreatePermissionService();
+            if (permissionService != null)
+            {
+                Assert.IsInstanceOfType(permissionService, typeof(PermissionService));
+            }
+            else
+            {
+                Assert.Fail($"PermissionService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex.Message}");
+        }
+    }
+
+#region "PermissionSystem"
+
+    [TestMethod]
+    public async Task GetPermissionSystemByGuidAsync_Null()
+    {
+        try
+        {
+
+            if (_permissionService != null)
+            {
+                var permission = await _permissionService.GetPermissionSystemByGuidAsync(Guid.NewGuid().ToString());
+                Assert.IsTrue(permission == null);
+            }
+            else
+            {
+                Assert.Fail($"PermissionService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetPermissionSystemByNameAsync_Null()
+    {
+        try
+        {
+
+            if (_permissionService != null)
+            {
+                var permission = await _permissionService.GetPermissionSystemByNameAsync(Guid.NewGuid().ToString());
+                Assert.IsTrue(permission == null);
+            }
+            else
+            {
+                Assert.Fail($"PermissionService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreatePermissionSystemAsync_Success()
+    {
+        try
+        {
+            var permission = await _permissionService.CreatePermissionSystemAsync(_name, true);
+            Assert.IsInstanceOfType(permission, typeof(PermissionSystem));
+            Assert.IsNotNull(permission);
+            Assert.IsTrue(permission.Name == _name);
+            Assert.IsTrue(permission.Enabled);
+            _permissionSystem = permission;
+
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreatePermissionSystemAsync_Exception()
+    {
+        try
+        {
+            var exceptionPermissionService = TestUtils.CreatePermissionServiceException();
+
+            if (exceptionPermissionService != null)
+            {
+                try
+                {
+                    var user = await exceptionPermissionService.CreatePermissionSystemAsync(_name, true);
+                    Assert.Fail($"Expected exception instead of response: {user?.Guid}");
+                }
+                catch (Exception exception)
+                {
+                    Assert.IsInstanceOfType(exception, typeof(Exception));
+                }
+            }
+            else
+            {
+                Assert.Fail($"PermissionService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task HandleEnabledPermissionSystem()
+    {
+        try
+        {
+            var updated = await _permissionService.HandleEnabledPermissionSystem(_permissionSystem, false);
+            Assert.IsTrue(updated);
+            Assert.IsTrue(!_permissionSystem.Enabled);
+
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetPermissionSystemByGuidAsync_Success()
+    {
+        try
+        {
+
+            if (_permissionService != null)
+            {
+                var permission = await _permissionService.GetPermissionSystemByGuidAsync(_permissionSystem.Guid);
+                Assert.IsNotNull(permission);
+                Assert.IsInstanceOfType(permission, typeof(PermissionSystem));
+                Assert.IsTrue(permission.Name == _permissionSystem.Name);
+                Assert.IsTrue(permission.Enabled == _permissionSystem.Enabled);
+            }
+            else
+            {
+                Assert.Fail($"PermissionService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetPermissionSystemByNameAsync_Success()
+    {
+        try
+        {
+
+            if (_permissionService != null)
+            {
+                var permission = await _permissionService.GetPermissionSystemByNameAsync(_permissionSystem.Name);
+                Assert.IsNotNull(permission);
+                Assert.IsInstanceOfType(permission, typeof(PermissionSystem));
+                Assert.IsTrue(permission.Guid == _permissionSystem.Guid);
+                Assert.IsTrue(permission.Enabled == _permissionSystem.Enabled);
+            }
+            else
+            {
+                Assert.Fail($"PermissionService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+#endregion
+    // [TestMethod]
+    // public async Task GetUserByUsernameAndPassword_Null()
+    // {
+    //     try
+    //     {
+    //         var testString = "test";
+    //         if (_userService != null)
+    //         {
+    //             var user = await _userService.GetUserByUsernameAndPassword(testString, testString);
+    //             Assert.IsTrue(user == null);
+    //         }
+    //         else
+    //         {
+    //             Assert.Fail($"PermissionService is null");
+    //         }
+    //     }
+    //     catch (Exception ex)
+    //     {
+    //         Console.WriteLine(ex.InnerException);
+    //         Assert.Fail($"An exception was thrown: {ex}");
+    //     }
+    // }
+
+    // [TestMethod]
+    // public async Task CheckIfEmailIsValid_EmailNotExists()
+    // {
+    //     try
+    //     {
+    //         if (_userService != null)
+    //         {
+    //             var valid = await _userService.CheckIfEmailIsValid(_user.Email ?? String.Empty);
+    //             Assert.IsTrue(valid);
+    //         }
+    //         else
+    //         {
+    //             Assert.Fail($"PermissionService is null");
+    //         }
+    //     }
+    //     catch (Exception ex)
+    //     {
+    //         Console.WriteLine(ex.InnerException);
+    //         Assert.Fail($"An exception was thrown: {ex}");
+    //     }
+    // }
+
+
+
+    // [TestMethod]
+    // public async Task CheckIfEmailIsValid_EmailCurrentUser()
+    // {
+    //     try
+    //     {
+
+    //         if (_userService != null)
+    //         {
+    //             var valid = await _userService.CheckIfEmailIsValid(_user.Email ?? String.Empty, _user.Guid ?? String.Empty);
+    //             Assert.IsTrue(valid);
+    //         }
+    //         else
+    //         {
+    //             Assert.Fail($"PermissionService is null");
+    //         }
+    //     }
+    //     catch (Exception ex)
+    //     {
+    //         Console.WriteLine(ex.InnerException);
+    //         Assert.Fail($"An exception was thrown: {ex}");
+    //     }
+    // }
+
+    // [TestMethod]
+    // public async Task CheckIfEmailIsValid_EmailAlreadyExists()
+    // {
+    //     try
+    //     {
+
+    //         if (_userService != null)
+    //         {
+    //             var valid = await _userService.CheckIfEmailIsValid(_user.Email ?? String.Empty);
+    //             Assert.IsFalse(valid);
+    //         }
+    //         else
+    //         {
+    //             Assert.Fail($"PermissionService is null");
+    //         }
+    //     }
+    //     catch (Exception ex)
+    //     {
+    //         Console.WriteLine(ex.InnerException);
+    //         Assert.Fail($"An exception was thrown: {ex}");
+    //     }
+    // }
+
+
+
+    // [TestMethod]
+    // public async Task GetUserByGuidAsync()
+    // {
+    //     try
+    //     {
+
+    //         if (_userService != null)
+    //         {
+    //             var user = await _userService.GetUserByGuidAsync(_user.Guid ?? String.Empty);
+    //             Assert.IsNotNull(user);
+    //             Assert.IsTrue(user.Guid == _user?.Guid);
+    //         }
+    //         else
+    //         {
+    //             Assert.Fail($"PermissionService is null");
+    //         }
+    //     }
+    //     catch (Exception ex)
+    //     {
+    //         Console.WriteLine(ex.InnerException);
+    //         Assert.Fail($"An exception was thrown: {ex}");
+    //     }
+    // }
+
+    // [TestMethod]
+    // public async Task DeleteUser()
+    // {
+    //     try
+    //     {
+
+    //         if (_userService != null)
+    //         {
+    //             var user = await _userService.GetUserByGuidAsync(_user.Guid ?? String.Empty);
+    //             Assert.IsNotNull(user);
+    //             var deleted = await _userService.DeleteUserAsync(user);
+    //             Assert.IsTrue(deleted);
+    //         }
+    //         else
+    //         {
+    //             Assert.Fail($"PermissionService is null");
+    //         }
+    //     }
+    //     catch (Exception ex)
+    //     {
+    //         Console.WriteLine(ex.InnerException);
+    //         Assert.Fail($"An exception was thrown: {ex}");
+    //     }
+    // }
+
+
+#region "DeletePermissions"
+    [TestMethod]
+    public async Task DeletePermissionSystemAsync()
+    {
+        try
+        {
+            var deleted = await _permissionService.DeletePermissionSystemAsync(_permissionSystem);
+            Assert.IsTrue(deleted);
+
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+#endregion
+
+}
+
+
+
diff --git a/MainProject.Tests/TestsUtils/TestUtils.cs b/MainProject.Tests/TestsUtils/TestUtils.cs
index aa21c64..e6f1bb8 100644
--- a/MainProject.Tests/TestsUtils/TestUtils.cs
+++ b/MainProject.Tests/TestsUtils/TestUtils.cs
@@ -145,6 +145,24 @@ public static class TestUtils
         var httpContextAccessor = new Mock<IHttpContextAccessor>();
         return new RoleService(httpContextAccessor.Object, configuration, sqlServerContext);
     }
+
+    public static PermissionService CreatePermissionService()
+    {
+        IConfiguration configuration = CreateConfiguration();
+        SqlServerContext sqlServerContext = CreateInMemorySqlContext();
+        var httpContextAccessor = new Mock<IHttpContextAccessor>();
+        return new PermissionService(httpContextAccessor.Object, configuration, sqlServerContext);
+    }
+
+    public static PermissionService CreatePermissionServiceException()
+    {
+        IConfiguration configuration = CreateConfiguration();
+        var optionsBuilder = new DbContextOptionsBuilder<SqlServerContext>();
+        optionsBuilder.UseSqlServer(GetFakeConnectionString());
+        SqlServerContext sqlServerContext = new SqlServerContext(optionsBuilder.Options);
+        var httpContextAccessor = new Mock<IHttpContextAccessor>();
+        return new PermissionService(httpContextAccessor.Object, configuration, sqlServerContext);
+    }
 }
 
 
diff --git a/MainProject/Services/PermissionService.cs b/MainProject/Services/PermissionService.cs
index ee7449a..5af03be 100644
--- a/MainProject/Services/PermissionService.cs
+++ b/MainProject/Services/PermissionService.cs
@@ -117,7 +117,7 @@ public class PermissionService : BaseService, IPermissionService
             .Where(x => !x.IsDeleted);
     }
 
-    private PermissionOperation CreatePermissionOperationData(string name)
+    private static PermissionOperation CreatePermissionOperationData(string name)
     {
         PermissionOperation permission = new()
         {
@@ -130,7 +130,7 @@ public class PermissionService : BaseService, IPermissionService
         return permission;
     }
 
-    private PermissionSystem CreatePermissionSystemData(string name, bool enabled)
+    private static PermissionSystem CreatePermissionSystemData(string name, bool enabled)
     {
         PermissionSystem permission = new()
         {
@@ -144,7 +144,7 @@ public class PermissionService : BaseService, IPermissionService
         return permission;
     }
 
-    private PermissionModule CreatePermissionModuleData(string name, bool enabled)
+    private static PermissionModule CreatePermissionModuleData(string name, bool enabled)
     {
         PermissionModule permission = new()
         {
@@ -158,7 +158,7 @@ public class PermissionService : BaseService, IPermissionService
         return permission;
     }
 
-    private PermissionSystemModule CreatePermissionSystemModuleData(
+    private static PermissionSystemModule CreatePermissionSystemModuleData(
         PermissionSystem permissionSystem,
         PermissionModule permissionModule,
         bool enabled
@@ -179,7 +179,7 @@ public class PermissionService : BaseService, IPermissionService
         return permission;
     }
 
-    private PermissionSystemModuleOperation CreatePermissionSystemModuleOperationData(
+    private static PermissionSystemModuleOperation CreatePermissionSystemModuleOperationData(
         PermissionSystemModule permissionSystemModule,
         PermissionOperation permissionOperation,
         bool enabled
@@ -200,7 +200,7 @@ public class PermissionService : BaseService, IPermissionService
         return permission;
     }
 
-    private RolePermissionSystemModuleOperation CreateRolePermissionSystemModuleOperationData(
+    private static RolePermissionSystemModuleOperation CreateRolePermissionSystemModuleOperationData(
         Role role, 
         PermissionSystemModuleOperation permissionModuleOperation, 
         bool active