Commit: d9592c8261e1d8f12e3f81bb057127423d2137fb - allura (git)

allura

Commit MetaInfo

• Revision: d9592c8261e1d8f12e3f81bb057127423d2137fb (tree)
• Time: 2010-05-22 00:20:00
• Author: Rick Copeland <rcopeland@geek...>
• Commiter: Rick Copeland

Log Message

[#424] - Modify permissions testing code to match what SOG has in FUSE, add tests

Change Summary

• modified: pyforge/pyforge/ext/user_profile/user_main.py
• modified: pyforge/pyforge/tests/functional/test_user_profile.py

Incremental Difference

--- a/pyforge/pyforge/ext/user_profile/user_main.py
+++ b/pyforge/pyforge/ext/user_profile/user_main.py
@@ -112,33 +112,39 @@ class UserProfileController(object):
     @expose('json')
     def permissions(self, repo_path=None, **kw):
         """Expects repo_path to be a filesystem path like
-        '/git/p/mygreatproject/reponame.git', or
-        '/svn/adobe/someproject/subproject/reponame/'.
-
-        Explicitly: (1) The path starts with a containing directory,
-        e.g., /git, which is not relevant.  (2) The final component of
-        the path is the repo name, and may include a trailing slash.
-        Less a '.git' suffix, the repo name _is_ the mount point.
-        (3) Everything between the containing directory and the repo is
-        an exact match for a project URL.  Multiple components
-        signify sub-projects.
-
-        Note that project and user _names_ are built with slashes, but
-        the supplied repo_path will use the os file separator character.
-        We know we'll get a user from our query because we're at that
-        user's profile page.
+            <tool>/<project>.<neighborhood>/reponame[.git]
+        unless the <neighborhood> is 'p', in which case it is
+            <tool>/<project>/reponame[.git]
 
         Returns JSON describing this user's permissions on that repo.
         """
 
+        disallow = dict(allow_read=False, allow_write=False, allow_create=False)
+        # Find the user
         username = c.project.shortname.split('/')[1]
         user = User.by_username(username)
+
         parts = [p for p in repo_path.split(os.path.sep) if p]
+        # strip the tool name
+        parts = parts[1:]
+        if '.' in parts[0]:
+            project, neighborhood = parts[0].split('.')
+        else:
+            project, neighborhood = parts[0], 'p'
+        parts = [ neighborhood, project ] + parts[1:]
         project_path = '/' + '/'.join(parts)
         project, rest = h.find_project(project_path)
+        if project is None:
+            log.info("Can't find project at %s from repo_path %s",
+                     project_path, repo_path)
+            return disallow
         mount_point = os.path.splitext(rest[0])[0]
         c.project = project
         c.app = project.app_instance(mount_point)
+        if c.app is None:
+            log.info("Can't find repo at %s on repo_path %s",
+                     mount_point, repo_path)
+            return disallow
         return dict(allow_read=has_artifact_access('read')(user=user),
                     allow_write=has_artifact_access('write')(user=user),
                     allow_create=has_artifact_access('create')(user=user))

--- a/pyforge/pyforge/tests/functional/test_user_profile.py
+++ b/pyforge/pyforge/tests/functional/test_user_profile.py
@@ -4,7 +4,6 @@ from formencode.variabledecode import variable_encode
 from ming.orm.ormsession import ThreadLocalORMSession
 
 from pyforge.tests import TestController
-from pyforge import model as M
 
 class TestUserProfile(TestController):
 
@@ -22,3 +21,54 @@ class TestUserProfile(TestController):
         assert 'Email Addresses' in response
         response = self.app.get('/u/test_user/profile/')
         assert 'Email Addresses' not in response
+
+class TestUserPermissions(TestController):
+    allow = dict(allow_read=True, allow_write=True, allow_create=True)
+    read = dict(allow_read=True, allow_write=False, allow_create=False)
+    disallow = dict(allow_read=False, allow_write=False, allow_create=False)
+
+    def test_unknown_project(self):
+        r = self._check_repo('/git/foo/bar')
+        assert r == self.disallow, r
+
+    def test_unknown_app(self):
+        r = self._check_repo('/git/test/bar')
+        assert r == self.disallow, r
+
+    def test_repo_write(self):
+        r = self._check_repo('/git/test/src.git')
+        assert r == self.allow, r
+        r = self._check_repo('/git/test/src')
+        assert r == self.allow, r
+
+    def test_subdir(self):
+        r = self._check_repo('/git/test/src.git/foo')
+        assert r == self.allow, r
+        r = self._check_repo('/git/test/src/foo')
+        assert r == self.allow, r
+
+    def test_neighborhood(self):
+        r = self._check_repo('/git/test.p/src.git')
+        assert r == self.allow, r
+
+    def test_repo_read(self):
+        r = self._check_repo(
+            '/git/test.p/src.git',
+            username='test_user')
+        assert r == self.read, r
+
+    def test_unknown_user(self):
+        r = self._check_repo(
+            '/git/test.p/src.git',
+            username='test_usera',
+            status=404)
+
+    def _check_repo(self, path, username='test_admin', **kw):
+        r = self.app.get(
+            '/u/%s/profile/permissions' % username,
+            params=dict(repo_path=path), **kw)
+        try:
+            return r.json
+        except:
+            return r
+