Include issue tracker hooks in builds

James Moger

2013-01-23 c7acc2e1fa86102bb87e715c8fe4e336329fbcc6

 tests/com/gitblit/tests/PermissionsTest.java

@@ -2327,8 +2327,9 @@
      repository.accessRestriction = AccessRestrictionType.VIEW;

      UserModel user = new UserModel("test");
      repository.owner = user.username;
      repository.addOwner(user.username);

      assertFalse("user SHOULD NOT HAVE a repository permission!", user.hasRepositoryPermission(repository.name));
      assertTrue("owner CAN NOT view!", user.canView(repository));
      assertTrue("owner CAN NOT clone!", user.canClone(repository));
      assertTrue("owner CAN NOT push!", user.canPush(repository));
@@ -2344,14 +2345,60 @@
   }
   
   @Test
   public void testMultipleOwners() throws Exception {
      RepositoryModel repository = new RepositoryModel("myrepo.git", null, null, new Date());
      repository.authorizationControl = AuthorizationControl.NAMED;
      repository.accessRestriction = AccessRestrictionType.VIEW;

      UserModel user = new UserModel("test");
      repository.addOwner(user.username);
      UserModel user2 = new UserModel("test2");
      repository.addOwner(user2.username);

      // first owner
      assertFalse("user SHOULD NOT HAVE a repository permission!", user.hasRepositoryPermission(repository.name));
      assertTrue("owner CAN NOT view!", user.canView(repository));
      assertTrue("owner CAN NOT clone!", user.canClone(repository));
      assertTrue("owner CAN NOT push!", user.canPush(repository));
		
      assertTrue("owner CAN NOT create ref!", user.canCreateRef(repository));
      assertTrue("owner CAN NOT delete ref!", user.canDeleteRef(repository));
      assertTrue("owner CAN NOT rewind ref!", user.canRewindRef(repository));

      assertTrue("owner CAN NOT fork!", user.canFork(repository));
		
      assertFalse("owner CAN NOT delete!", user.canDelete(repository));
      assertTrue("owner CAN NOT edit!", user.canEdit(repository));
		
      // second owner
      assertFalse("user SHOULD NOT HAVE a repository permission!", user2.hasRepositoryPermission(repository.name));
      assertTrue("owner CAN NOT view!", user2.canView(repository));
      assertTrue("owner CAN NOT clone!", user2.canClone(repository));
      assertTrue("owner CAN NOT push!", user2.canPush(repository));
		
      assertTrue("owner CAN NOT create ref!", user2.canCreateRef(repository));
      assertTrue("owner CAN NOT delete ref!", user2.canDeleteRef(repository));
      assertTrue("owner CAN NOT rewind ref!", user2.canRewindRef(repository));

      assertTrue("owner CAN NOT fork!", user2.canFork(repository));
		
      assertFalse("owner CAN NOT delete!", user2.canDelete(repository));
      assertTrue("owner CAN NOT edit!", user2.canEdit(repository));
		
      assertTrue(repository.isOwner(user.username));
      assertTrue(repository.isOwner(user2.username));	
   }
	
   @Test
   public void testOwnerPersonalRepository() throws Exception {
      RepositoryModel repository = new RepositoryModel("~test/myrepo.git", null, null, new Date());
      repository.authorizationControl = AuthorizationControl.NAMED;
      repository.accessRestriction = AccessRestrictionType.VIEW;

      UserModel user = new UserModel("test");
      repository.owner = user.username;
      repository.addOwner(user.username);

      assertFalse("user SHOULD NOT HAVE a repository permission!", user.hasRepositoryPermission(repository.name));
      assertTrue("user CAN NOT view!", user.canView(repository));
      assertTrue("user CAN NOT clone!", user.canClone(repository));
      assertTrue("user CAN NOT push!", user.canPush(repository));
@@ -2373,8 +2420,9 @@
      repository.accessRestriction = AccessRestrictionType.VIEW;

      UserModel user = new UserModel("visitor");
      repository.owner = "test";
      repository.addOwner("test");

      assertFalse("user HAS a repository permission!", user.hasRepositoryPermission(repository.name));
      assertFalse("user CAN view!", user.canView(repository));
      assertFalse("user CAN clone!", user.canClone(repository));
      assertFalse("user CAN push!", user.canPush(repository));
@@ -2388,4 +2436,200 @@
      assertFalse("user CAN delete!", user.canDelete(repository));
      assertFalse("user CAN edit!", user.canEdit(repository));
   }
	
   @Test
   public void testRegexMatching() throws Exception {
      RepositoryModel repository = new RepositoryModel("ubercool/_my-r/e~po.git", null, null, new Date());
      repository.authorizationControl = AuthorizationControl.NAMED;
      repository.accessRestriction = AccessRestrictionType.VIEW;

      UserModel user = new UserModel("test");
      user.setRepositoryPermission("ubercool/[A-Z0-9-~_\\./]+", AccessPermission.CLONE);

      assertTrue("user DOES NOT HAVE a repository permission!", user.hasRepositoryPermission(repository.name));
      assertTrue("user CAN NOT view!", user.canView(repository));
      assertTrue("user CAN NOT clone!", user.canClone(repository));
      assertFalse("user CAN push!", user.canPush(repository));
		
      assertFalse("user CAN create ref!", user.canCreateRef(repository));
      assertFalse("user CAN delete ref!", user.canDeleteRef(repository));
      assertFalse("user CAN rewind ref!", user.canRewindRef(repository));

      assertFalse("user CAN fork!", user.canFork(repository));
		
      assertFalse("user CAN delete!", user.canDelete(repository));
      assertFalse("user CAN edit!", user.canEdit(repository));
   }

   @Test
   public void testRegexIncludeCommonExcludePersonal() throws Exception {
		
      UserModel user = new UserModel("test");
      user.setRepositoryPermission("[^~].*", AccessPermission.CLONE);

      // common
      RepositoryModel common = new RepositoryModel("ubercool/_my-r/e~po.git", null, null, new Date());
      common.authorizationControl = AuthorizationControl.NAMED;
      common.accessRestriction = AccessRestrictionType.VIEW;
		
      assertTrue("user DOES NOT HAVE a repository permission!", user.hasRepositoryPermission(common.name));
      assertTrue("user CAN NOT view!", user.canView(common));
      assertTrue("user CAN NOT clone!", user.canClone(common));
      assertFalse("user CAN push!", user.canPush(common));
		
      assertFalse("user CAN create ref!", user.canCreateRef(common));
      assertFalse("user CAN delete ref!", user.canDeleteRef(common));
      assertFalse("user CAN rewind ref!", user.canRewindRef(common));

      assertFalse("user CAN fork!", user.canFork(common));
		
      assertFalse("user CAN delete!", user.canDelete(common));
      assertFalse("user CAN edit!", user.canEdit(common));

      // personal
      RepositoryModel personal = new RepositoryModel("~ubercool/_my-r/e~po.git", null, null, new Date());
      personal.authorizationControl = AuthorizationControl.NAMED;
      personal.accessRestriction = AccessRestrictionType.VIEW;
		
      assertFalse("user HAS a repository permission!", user.hasRepositoryPermission(personal.name));
      assertFalse("user CAN NOT view!", user.canView(personal));
      assertFalse("user CAN NOT clone!", user.canClone(personal));
      assertFalse("user CAN push!", user.canPush(personal));
		
      assertFalse("user CAN create ref!", user.canCreateRef(personal));
      assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
      assertFalse("user CAN rewind ref!", user.canRewindRef(personal));

      assertFalse("user CAN fork!", user.canFork(personal));
		
      assertFalse("user CAN delete!", user.canDelete(personal));
      assertFalse("user CAN edit!", user.canEdit(personal));
   }
	
   @Test
   public void testRegexMatching2() throws Exception {
      RepositoryModel personal = new RepositoryModel("~ubercool/_my-r/e~po.git", null, null, new Date());
      personal.authorizationControl = AuthorizationControl.NAMED;
      personal.accessRestriction = AccessRestrictionType.VIEW;

      UserModel user = new UserModel("test");
      // permit all repositories excluding all personal rpeositories
      user.setRepositoryPermission("[^~].*", AccessPermission.CLONE);
      // permitall  ~ubercool repositories
      user.setRepositoryPermission("~ubercool/.*", AccessPermission.CLONE);
		
      // personal
      assertTrue("user DOES NOT HAVE a repository permission!", user.hasRepositoryPermission(personal.name));
      assertTrue("user CAN NOT view!", user.canView(personal));
      assertTrue("user CAN NOT clone!", user.canClone(personal));
      assertFalse("user CAN push!", user.canPush(personal));
		
      assertFalse("user CAN create ref!", user.canCreateRef(personal));
      assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
      assertFalse("user CAN rewind ref!", user.canRewindRef(personal));

      assertFalse("user CAN fork!", user.canFork(personal));
		
      assertFalse("user CAN delete!", user.canDelete(personal));
      assertFalse("user CAN edit!", user.canEdit(personal));
   }
	
   @Test
   public void testRegexOrder() throws Exception {
      RepositoryModel personal = new RepositoryModel("~ubercool/_my-r/e~po.git", null, null, new Date());
      personal.authorizationControl = AuthorizationControl.NAMED;
      personal.accessRestriction = AccessRestrictionType.VIEW;

      UserModel user = new UserModel("test");
      user.setRepositoryPermission(".*", AccessPermission.PUSH);
      user.setRepositoryPermission("~ubercool/.*", AccessPermission.CLONE);
		
      // has PUSH access because first match is PUSH permission 
      assertTrue("user HAS a repository permission!", user.hasRepositoryPermission(personal.name));
      assertTrue("user CAN NOT view!", user.canView(personal));
      assertTrue("user CAN NOT clone!", user.canClone(personal));
      assertTrue("user CAN NOT push!", user.canPush(personal));
		
      assertFalse("user CAN create ref!", user.canCreateRef(personal));
      assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
      assertFalse("user CAN rewind ref!", user.canRewindRef(personal));

      assertFalse("user CAN fork!", user.canFork(personal));
		
      assertFalse("user CAN delete!", user.canDelete(personal));
      assertFalse("user CAN edit!", user.canEdit(personal));
				
      user.permissions.clear();
      user.setRepositoryPermission("~ubercool/.*", AccessPermission.CLONE);
      user.setRepositoryPermission(".*", AccessPermission.PUSH);
		
      // has CLONE access because first match is CLONE permission
      assertTrue("user HAS a repository permission!", user.hasRepositoryPermission(personal.name));
      assertTrue("user CAN NOT view!", user.canView(personal));
      assertTrue("user CAN NOT clone!", user.canClone(personal));
      assertFalse("user CAN push!", user.canPush(personal));
				
      assertFalse("user CAN create ref!", user.canCreateRef(personal));
      assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
      assertFalse("user CAN rewind ref!", user.canRewindRef(personal));

      assertFalse("user CAN fork!", user.canFork(personal));
				
      assertFalse("user CAN delete!", user.canDelete(personal));
      assertFalse("user CAN edit!", user.canEdit(personal));
   }
	
   @Test
   public void testExclusion() throws Exception {
      RepositoryModel personal = new RepositoryModel("~ubercool/_my-r/e~po.git", null, null, new Date());
      personal.authorizationControl = AuthorizationControl.NAMED;
      personal.accessRestriction = AccessRestrictionType.VIEW;

      UserModel user = new UserModel("test");
      user.setRepositoryPermission("~ubercool/.*", AccessPermission.EXCLUDE);
      user.setRepositoryPermission(".*", AccessPermission.PUSH);
		
      // has EXCLUDE access because first match is EXCLUDE permission
      assertTrue("user DOES NOT HAVE a repository permission!", user.hasRepositoryPermission(personal.name));
      assertFalse("user CAN NOT view!", user.canView(personal));
      assertFalse("user CAN NOT clone!", user.canClone(personal));
      assertFalse("user CAN push!", user.canPush(personal));
				
      assertFalse("user CAN create ref!", user.canCreateRef(personal));
      assertFalse("user CAN delete ref!", user.canDeleteRef(personal));
      assertFalse("user CAN rewind ref!", user.canRewindRef(personal));

      assertFalse("user CAN fork!", user.canFork(personal));
				
      assertFalse("user CAN delete!", user.canDelete(personal));
      assertFalse("user CAN edit!", user.canEdit(personal));
   }

   @Test
   public void testAdminTeamInheritance() throws Exception {
      UserModel user = new UserModel("test");
      TeamModel team = new TeamModel("team");
      team.canAdmin = true;
      user.teams.add(team);
      assertTrue("User did not inherit admin privileges", user.canAdmin());
   }
	
   @Test
   public void testForkTeamInheritance() throws Exception {
      UserModel user = new UserModel("test");
      TeamModel team = new TeamModel("team");
      team.canFork = true;
      user.teams.add(team);
      assertTrue("User did not inherit fork privileges", user.canFork());
   }

   @Test
   public void testCreateTeamInheritance() throws Exception {
      UserModel user = new UserModel("test");
      TeamModel team = new TeamModel("team");
      team.canCreate= true;
      user.teams.add(team);
      assertTrue("User did not inherit create privileges", user.canCreate());
   }

}