Improve effective permission determination

diff --git a/src/main/java/com/gitblit/Constants.java b/src/main/java/com/gitblit/Constants.java
index 7663f8bd9f5c25f48d6ddd42f9497e14b5b277ef..5bd5b600eabd9daaa7c38861e28a0886e3ceeac8 100644 (file)
--- a/src/main/java/com/gitblit/Constants.java
+++ b/src/main/java/com/gitblit/Constants.java
@@ -147,6 +147,28 @@ public class Constants {
                public String toString() {\r
                        return name();\r
                }\r
+               \r
+               public boolean isValidPermission(AccessPermission permission) {\r
+                       switch (this) {\r
+                       case VIEW:\r
+                               // VIEW restriction\r
+                               // all access permissions are valid\r
+                               return true;\r
+                       case CLONE:\r
+                               // CLONE restriction\r
+                               // only CLONE or greater access permissions are valid\r
+                               return permission.atLeast(AccessPermission.CLONE);\r
+                       case PUSH:\r
+                               // PUSH restriction\r
+                               // only PUSH or greater access permissions are valid \r
+                               return permission.atLeast(AccessPermission.PUSH);\r
+                       case NONE:\r
+                               // NO access restriction\r
+                               // all access permissions are invalid\r
+                               return false;\r
+                       }\r
+                       return false;\r
+               }\r
        }\r
        \r
        /**\r
@@ -416,7 +438,7 @@ public class Constants {
        }\r
        \r
        public static enum PermissionType {\r
-               MISSING, EXPLICIT, TEAM, REGEX, OWNER, ADMINISTRATOR;\r
+               MISSING, ANONYMOUS, EXPLICIT, TEAM, REGEX, OWNER, ADMINISTRATOR;\r
        }\r
        \r
        public static enum GCStatus {\r

diff --git a/src/main/java/com/gitblit/models/TeamModel.java b/src/main/java/com/gitblit/models/TeamModel.java
index 9587ca7a34271c3c3e7ea1e8130c256c90e7e5ea..8e0d5d5c9b3b66dd6c3e96b8ff9fbabd30812158 100644 (file)
--- a/src/main/java/com/gitblit/models/TeamModel.java
+++ b/src/main/java/com/gitblit/models/TeamModel.java
@@ -197,6 +197,13 @@ public class TeamModel implements Serializable, Comparable<TeamModel> {
                ap.permission = AccessPermission.NONE;\r
                ap.mutable = false;\r
                \r
+               if (AccessRestrictionType.NONE.equals(repository.accessRestriction)) {\r
+                       // anonymous rewind\r
+                       ap.permissionType = PermissionType.ANONYMOUS;\r
+                       ap.permission = AccessPermission.REWIND;\r
+                       return ap;\r
+               }\r
+               \r
                if (canAdmin) {\r
                        ap.permissionType = PermissionType.ADMINISTRATOR;\r
                        ap.permission = AccessPermission.REWIND;\r
@@ -206,7 +213,7 @@ public class TeamModel implements Serializable, Comparable<TeamModel> {
                if (permissions.containsKey(repository.name.toLowerCase())) {\r
                        // exact repository permission specified\r
                        AccessPermission p = permissions.get(repository.name.toLowerCase());\r
-                       if (p != null) {\r
+                       if (p != null && repository.accessRestriction.isValidPermission(p)) {\r
                                ap.permissionType = PermissionType.EXPLICIT;\r
                                ap.permission = p;\r
                                ap.mutable = true;\r
@@ -217,7 +224,7 @@ public class TeamModel implements Serializable, Comparable<TeamModel> {
                        for (String key : permissions.keySet()) {\r
                                if (StringUtils.matchesIgnoreCase(repository.name, key)) {\r
                                        AccessPermission p = permissions.get(key);\r
-                                       if (p != null) {\r
+                                       if (p != null && repository.accessRestriction.isValidPermission(p)) {\r
                                                // take first match\r
                                                ap.permissionType = PermissionType.REGEX;\r
                                                ap.permission = p;\r
@@ -227,6 +234,31 @@ public class TeamModel implements Serializable, Comparable<TeamModel> {
                                }\r
                        }\r
                }\r
+               \r
+               // still no explicit or regex, check for implicit permissions\r
+               if (AccessPermission.NONE == ap.permission) {\r
+                       switch (repository.accessRestriction) {\r
+                       case VIEW:\r
+                               // no implicit permissions possible\r
+                               break;\r
+                       case CLONE:\r
+                               // implied view permission\r
+                               ap.permission = AccessPermission.VIEW;\r
+                               ap.permissionType = PermissionType.ANONYMOUS;\r
+                               break;\r
+                       case PUSH:\r
+                               // implied clone permission\r
+                               ap.permission = AccessPermission.CLONE;\r
+                               ap.permissionType = PermissionType.ANONYMOUS;\r
+                               break;\r
+                       case NONE:\r
+                               // implied REWIND or CLONE if frozen\r
+                               ap.permission = repository.isFrozen ? AccessPermission.CLONE : AccessPermission.REWIND;\r
+                               ap.permissionType = PermissionType.ANONYMOUS;\r
+                               break;\r
+                       }\r
+               }\r
+\r
                return ap;\r
        }\r
        \r

diff --git a/src/main/java/com/gitblit/models/UserModel.java b/src/main/java/com/gitblit/models/UserModel.java
index bec011d93f139bd8180bb031bee95c0eab692030..5750d46a294bf2aa3d230be395229d399e62a968 100644 (file)
--- a/src/main/java/com/gitblit/models/UserModel.java
+++ b/src/main/java/com/gitblit/models/UserModel.java
@@ -281,7 +281,7 @@ public class UserModel implements Principal, Serializable, Comparable<UserModel>
 \r
                if (AccessRestrictionType.NONE.equals(repository.accessRestriction)) {\r
                        // anonymous rewind\r
-                       ap.permissionType = PermissionType.ADMINISTRATOR;\r
+                       ap.permissionType = PermissionType.ANONYMOUS;\r
                        ap.permission = AccessPermission.REWIND;\r
                        return ap;\r
                }\r
@@ -320,7 +320,7 @@ public class UserModel implements Principal, Serializable, Comparable<UserModel>
                if (permissions.containsKey(repository.name.toLowerCase())) {\r
                        // exact repository permission specified, use it\r
                        AccessPermission p = permissions.get(repository.name.toLowerCase());\r
-                       if (p != null) {\r
+                       if (p != null && repository.accessRestriction.isValidPermission(p)) {\r
                                ap.permissionType = PermissionType.EXPLICIT;\r
                                ap.permission = p;\r
                                ap.mutable = true;\r
@@ -331,7 +331,7 @@ public class UserModel implements Principal, Serializable, Comparable<UserModel>
                        for (String key : permissions.keySet()) {\r
                                if (StringUtils.matchesIgnoreCase(repository.name, key)) {\r
                                        AccessPermission p = permissions.get(key);\r
-                                       if (p != null) {\r
+                                       if (p != null && repository.accessRestriction.isValidPermission(p)) {\r
                                                // take first match\r
                                                ap.permissionType = PermissionType.REGEX;\r
                                                ap.permission = p;\r
@@ -345,13 +345,37 @@ public class UserModel implements Principal, Serializable, Comparable<UserModel>
                // try to find a team match\r
                for (TeamModel team : teams) {\r
                        RegistrantAccessPermission p = team.getRepositoryPermission(repository);\r
-                       if (p.permission.exceeds(ap.permission)) {\r
-                               // use highest team permission\r
+                       if (p.permission.exceeds(ap.permission) && PermissionType.ANONYMOUS != p.permissionType) {\r
+                               // use highest team permission that is not an implicit permission\r
                                ap.permission = p.permission;\r
                                ap.source = team.name;\r
                                ap.permissionType = PermissionType.TEAM;\r
                        }\r
-               }               \r
+               }\r
+               \r
+               // still no explicit, regex, or team match, check for implicit permissions\r
+               if (AccessPermission.NONE == ap.permission) {\r
+                       switch (repository.accessRestriction) {\r
+                       case VIEW:\r
+                               // no implicit permissions possible\r
+                               break;\r
+                       case CLONE:\r
+                               // implied view permission\r
+                               ap.permission = AccessPermission.VIEW;\r
+                               ap.permissionType = PermissionType.ANONYMOUS;\r
+                               break;\r
+                       case PUSH:\r
+                               // implied clone permission\r
+                               ap.permission = AccessPermission.CLONE;\r
+                               ap.permissionType = PermissionType.ANONYMOUS;\r
+                               break;\r
+                       case NONE:\r
+                               // implied REWIND or CLONE if frozen\r
+                               ap.permission = repository.isFrozen ? AccessPermission.CLONE : AccessPermission.REWIND;\r
+                               ap.permissionType = PermissionType.ANONYMOUS;\r
+                               break;\r
+                       }\r
+               }\r
                \r
                return ap;\r
        }\r

diff --git a/src/test/java/com/gitblit/tests/PermissionsTest.java b/src/test/java/com/gitblit/tests/PermissionsTest.java
index 5a951042216a232a3c9e1ad89dcc80b0a654115b..a094f9a970538d6750037d88f479cac61169e7c2 100644 (file)
--- a/src/test/java/com/gitblit/tests/PermissionsTest.java
+++ b/src/test/java/com/gitblit/tests/PermissionsTest.java
@@ -17,7 +17,7 @@ package com.gitblit.tests;
 
 import java.util.Date;
 
-import junit.framework.Assert;
+import org.junit.Assert;
 
 import org.junit.Test;
 
@@ -57,6 +57,8 @@ public class PermissionsTest extends Assert {
                        assertTrue("admin CAN NOT delete ref!", user.canDeleteRef(repository));
                        assertTrue("admin CAN NOT rewind ref!", user.canRewindRef(repository));
                        
+                       assertEquals("admin has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                        assertTrue("admin CAN NOT fork!", user.canFork(repository));
                        
                        assertTrue("admin CAN NOT delete!", user.canDelete(repository));
@@ -74,7 +76,7 @@ public class PermissionsTest extends Assert {
                repository.accessRestriction = AccessRestrictionType.NONE;
                
                UserModel user = UserModel.ANONYMOUS;
-               
+                               
                // all permissions, except fork
                assertTrue("anonymous CAN NOT view!", user.canView(repository));
                assertTrue("anonymous CAN NOT clone!", user.canClone(repository));
@@ -84,6 +86,8 @@ public class PermissionsTest extends Assert {
                assertTrue("anonymous CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("anonymous CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("anonymous has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                assertFalse("anonymous CAN fork!", user.canFork(repository));
                repository.allowForks = true;
@@ -109,6 +113,8 @@ public class PermissionsTest extends Assert {
                assertFalse("anonymous CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("anonymous CAN rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("anonymous has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                assertFalse("anonymous CAN fork!", user.canFork(repository));
                repository.allowForks = true;
@@ -131,6 +137,8 @@ public class PermissionsTest extends Assert {
                assertFalse("anonymous CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("anonymous CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("anonymous has wrong permission!", AccessPermission.VIEW, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                assertFalse("anonymous CAN fork!", user.canFork(repository));
                repository.allowForks = true;
@@ -153,6 +161,8 @@ public class PermissionsTest extends Assert {
                assertFalse("anonymous CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("anonymous CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("anonymous has wrong permission!", AccessPermission.NONE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                assertFalse("anonymous CAN fork!", user.canFork(repository));
                repository.allowForks = true;
@@ -179,6 +189,8 @@ public class PermissionsTest extends Assert {
                assertTrue("authenticated CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("authenticated CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("authenticated has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                user.canFork = false;
                repository.allowForks = false;
                assertFalse("authenticated CAN fork!", user.canFork(repository));
@@ -207,6 +219,8 @@ public class PermissionsTest extends Assert {
                assertTrue("authenticated CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("authenticated CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("authenticated has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                user.canFork = false;
                repository.allowForks = false;
                assertFalse("authenticated CAN fork!", user.canFork(repository));
@@ -232,6 +246,8 @@ public class PermissionsTest extends Assert {
                assertTrue("authenticated CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("authenticated CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("authenticated has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                user.canFork = false;
                repository.allowForks = false;
                assertFalse("authenticated CAN fork!", user.canFork(repository));
@@ -257,6 +273,8 @@ public class PermissionsTest extends Assert {
                assertTrue("authenticated CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("authenticated CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("authenticated has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                user.canFork = false;
                repository.allowForks = false;
                assertFalse("authenticated CAN fork!", user.canFork(repository));
@@ -285,6 +303,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -316,6 +336,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -344,6 +366,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.VIEW, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -372,6 +396,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.NONE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -402,7 +428,9 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
-               
+
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -432,6 +460,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -461,6 +491,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.VIEW, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -490,6 +522,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.VIEW, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -520,6 +554,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -533,7 +569,7 @@ public class PermissionsTest extends Assert {
         * PUSH_CLONE = PUSH access restriction, CLONE access permission
         */
        @Test
-       public void testNamed_PUSH_READ() throws Exception {
+       public void testNamed_PUSH_CLONE() throws Exception {
                RepositoryModel repository = new RepositoryModel("myrepo.git", null, null, new Date());
                repository.authorizationControl = AuthorizationControl.NAMED;
                repository.accessRestriction = AccessRestrictionType.PUSH;
@@ -549,6 +585,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -578,6 +616,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -607,6 +647,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -637,6 +679,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -666,6 +710,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.PUSH, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -695,6 +741,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete red!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.PUSH, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -724,6 +772,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.PUSH, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -754,6 +804,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -783,6 +835,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.CREATE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -812,6 +866,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete red!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.CREATE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -841,6 +897,8 @@ public class PermissionsTest extends Assert {
                assertFalse("named CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.CREATE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -871,6 +929,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -900,6 +960,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.DELETE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -929,6 +991,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete red!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.DELETE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -958,6 +1022,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertFalse("named CAN rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.DELETE, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -988,6 +1054,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -1017,6 +1085,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -1046,6 +1116,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -1075,6 +1147,8 @@ public class PermissionsTest extends Assert {
                assertTrue("named CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("named CAN NOT rewind ref!", user.canRewindRef(repository));
                
+               assertEquals("named has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                repository.allowForks = false;
                user.canFork = false;
                assertFalse("named CAN fork!", user.canFork(repository));
@@ -1102,6 +1176,9 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+               
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
+
        }
        
        /**
@@ -1122,6 +1199,9 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+               
+               assertEquals("team has wrong permission!", AccessPermission.CLONE, team.getRepositoryPermission(repository).permission);
+
        }
 
        /**
@@ -1142,6 +1222,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+               
+               assertEquals("team has wrong permission!", AccessPermission.VIEW, team.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -1162,6 +1244,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+               
+               assertEquals("team has wrong permission!", AccessPermission.NONE, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1184,6 +1268,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+               
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1205,6 +1291,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+               
+               assertEquals("team has wrong permission!", AccessPermission.PUSH, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1226,6 +1314,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+               
+               assertEquals("team has wrong permission!", AccessPermission.PUSH, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1247,6 +1337,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.PUSH, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1269,6 +1361,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1290,6 +1384,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.CREATE, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1311,6 +1407,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.CREATE, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1332,6 +1430,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.CREATE, team.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -1354,6 +1454,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1375,6 +1477,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.DELETE, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1396,6 +1500,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+               
+               assertEquals("team has wrong permission!", AccessPermission.DELETE, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1417,6 +1523,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.DELETE, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1439,6 +1547,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1460,6 +1570,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1481,6 +1593,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1502,6 +1616,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1524,6 +1640,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -1545,6 +1663,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.CLONE, team.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -1566,6 +1686,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.CLONE, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1587,6 +1709,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.CLONE, team.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -1609,6 +1733,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team CAN NOT create ref!", team.canCreateRef(repository));
                assertTrue("team CAN NOT delete ref!", team.canDeleteRef(repository));
                assertTrue("team CAN NOT rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.REWIND, team.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -1630,6 +1756,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.CLONE, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1651,6 +1779,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.VIEW, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1672,6 +1802,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team CAN create ref!", team.canCreateRef(repository));
                assertFalse("team CAN delete ref!", team.canDeleteRef(repository));
                assertFalse("team CAN rewind ref!", team.canRewindRef(repository));
+
+               assertEquals("team has wrong permission!", AccessPermission.VIEW, team.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1694,6 +1826,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1716,6 +1850,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -1738,6 +1874,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.VIEW, user.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -1760,6 +1898,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.NONE, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1784,6 +1924,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1807,6 +1949,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.PUSH, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1830,6 +1974,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.PUSH, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1853,6 +1999,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.PUSH, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1877,6 +2025,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1900,6 +2050,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.CREATE, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1923,6 +2075,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.CREATE, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1946,6 +2100,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.CREATE, user.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -1970,6 +2126,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -1993,6 +2151,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.DELETE, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -2016,6 +2176,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.DELETE, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -2039,6 +2201,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.DELETE, user.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -2063,6 +2227,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -2086,6 +2252,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -2109,6 +2277,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -2132,6 +2302,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -2156,6 +2328,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -2179,6 +2353,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -2202,6 +2378,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -2225,6 +2403,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -2249,6 +2429,8 @@ public class PermissionsTest extends Assert {
                assertTrue("team member CAN NOT create ref!", user.canCreateRef(repository));
                assertTrue("team member CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("team member CAN NOT rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
        }
 
        /**
@@ -2272,6 +2454,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -2295,6 +2479,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.VIEW, user.getRepositoryPermission(repository).permission);
        }
        
        /**
@@ -2318,6 +2504,8 @@ public class PermissionsTest extends Assert {
                assertFalse("team member CAN create ref!", user.canCreateRef(repository));
                assertFalse("team member CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("team member CAN rewind ref!", user.canRewindRef(repository));
+
+               assertEquals("team member has wrong permission!", AccessPermission.VIEW, user.getRepositoryPermission(repository).permission);
        }
        
        @Test
@@ -2338,6 +2526,8 @@ public class PermissionsTest extends Assert {
                assertTrue("owner CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("owner CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("owner has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                assertTrue("owner CAN NOT fork!", user.canFork(repository));
                
                assertFalse("owner CAN NOT delete!", user.canDelete(repository));
@@ -2365,6 +2555,8 @@ public class PermissionsTest extends Assert {
                assertTrue("owner CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("owner CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("owner has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                assertTrue("owner CAN NOT fork!", user.canFork(repository));
                
                assertFalse("owner CAN NOT delete!", user.canDelete(repository));
@@ -2380,6 +2572,8 @@ public class PermissionsTest extends Assert {
                assertTrue("owner CAN NOT delete ref!", user2.canDeleteRef(repository));
                assertTrue("owner CAN NOT rewind ref!", user2.canRewindRef(repository));
 
+               assertEquals("owner has wrong permission!", AccessPermission.REWIND, user2.getRepositoryPermission(repository).permission);
+
                assertTrue("owner CAN NOT fork!", user2.canFork(repository));
                
                assertFalse("owner CAN NOT delete!", user2.canDelete(repository));
@@ -2407,6 +2601,8 @@ public class PermissionsTest extends Assert {
                assertTrue("user CAN NOT delete ref!", user.canDeleteRef(repository));
                assertTrue("user CAN NOT rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("user has wrong permission!", AccessPermission.REWIND, user.getRepositoryPermission(repository).permission);
+
                assertFalse("user CAN fork!", user.canFork(repository));
                
                assertTrue("user CAN NOT delete!", user.canDelete(repository));
@@ -2431,6 +2627,8 @@ public class PermissionsTest extends Assert {
                assertFalse("user CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("user CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("user has wrong permission!", AccessPermission.NONE, user.getRepositoryPermission(repository).permission);
+
                assertFalse("user CAN fork!", user.canFork(repository));
                
                assertFalse("user CAN delete!", user.canDelete(repository));
@@ -2455,6 +2653,8 @@ public class PermissionsTest extends Assert {
                assertFalse("user CAN delete ref!", user.canDeleteRef(repository));
                assertFalse("user CAN rewind ref!", user.canRewindRef(repository));
 
+               assertEquals("user has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(repository).permission);
+
                assertFalse("user CAN fork!", user.canFork(repository));
                
                assertFalse("user CAN delete!", user.canDelete(repository));
@@ -2481,6 +2681,8 @@ public class PermissionsTest extends Assert {
                assertFalse("user CAN delete ref!", user.canDeleteRef(common));
                assertFalse("user CAN rewind ref!", user.canRewindRef(common));
 
+               assertEquals("user has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(common).permission);
+
                assertFalse("user CAN fork!", user.canFork(common));
                
                assertFalse("user CAN delete!", user.canDelete(common));
@@ -2500,6 +2702,8 @@ public class PermissionsTest extends Assert {
                assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
                assertFalse("user CAN rewind ref!", user.canRewindRef(personal));
 
+               assertEquals("user has wrong permission!", AccessPermission.NONE, user.getRepositoryPermission(personal).permission);
+
                assertFalse("user CAN fork!", user.canFork(personal));
                
                assertFalse("user CAN delete!", user.canDelete(personal));
@@ -2528,6 +2732,8 @@ public class PermissionsTest extends Assert {
                assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
                assertFalse("user CAN rewind ref!", user.canRewindRef(personal));
 
+               assertEquals("user has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(personal).permission);
+
                assertFalse("user CAN fork!", user.canFork(personal));
                
                assertFalse("user CAN delete!", user.canDelete(personal));
@@ -2554,6 +2760,8 @@ public class PermissionsTest extends Assert {
                assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
                assertFalse("user CAN rewind ref!", user.canRewindRef(personal));
 
+               assertEquals("user has wrong permission!", AccessPermission.PUSH, user.getRepositoryPermission(personal).permission);
+
                assertFalse("user CAN fork!", user.canFork(personal));
                
                assertFalse("user CAN delete!", user.canDelete(personal));
@@ -2573,6 +2781,8 @@ public class PermissionsTest extends Assert {
                assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
                assertFalse("user CAN rewind ref!", user.canRewindRef(personal));
 
+               assertEquals("user has wrong permission!", AccessPermission.CLONE, user.getRepositoryPermission(personal).permission);
+
                assertFalse("user CAN fork!", user.canFork(personal));
                                
                assertFalse("user CAN delete!", user.canDelete(personal));
@@ -2599,6 +2809,8 @@ public class PermissionsTest extends Assert {
                assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
                assertFalse("user CAN rewind ref!", user.canRewindRef(personal));
 
+               assertEquals("user has wrong permission!", AccessPermission.EXCLUDE, user.getRepositoryPermission(personal).permission);
+
                assertFalse("user CAN fork!", user.canFork(personal));
                                
                assertFalse("user CAN delete!", user.canDelete(personal));