cserver = CrowdServer(host="127.0.0.1",

                                  port="8095",

                                  user="some_app",

                                  passwd="some_passwd",

                                  version="1")

        """

            kwargs["port"] = "8095"

        self._logger = kwargs.get("logger", logging.getLogger(__name__))

        self._uri = "%s://%s:%s/crowd" % (kwargs.get("method", "http"),

                                    kwargs.get("host", "127.0.0.1"),

                                    kwargs.get("port", "8095"))

        self.set_credentials(kwargs.get("user", ""),

                # Loop over the stored fields in the index

                for fields in reader.all_stored_fields():

                    indexed_path = fields['path']

                    indexed_repo_path = fields['repository']

                    indexed_paths.add(indexed_path)

                        continue

                    repo = self.repo_paths[indexed_repo_path]

                    try:

                        node = self.get_node(repo, indexed_path)

            path = path.rstrip('/')

        return path

    def _get_id_for_path(self, path):

        path = safe_str(path)

        # FIXME: Please, spare a couple of minutes and make those codes cleaner;

            path = path.strip('/')

            # set root tree

            tree = self.repository._repo[self._tree_id]

            if path == '':

                self._paths[''] = tree.id

                return tree.id

                    if curdir:

                        name = '/'.join((curdir, item))

                    else:

                        name = item

                    self._paths[name] = id

                    self._stat_modes[name] = stat

                raise NodeDoesNotExistError("There is no file nor directory "

                    "at the given path '%s' at revision %s"

                    % (path, safe_str(self.short_id)))

        return self._paths[path]

    def _get_kind(self, path):

                filenodes.append(FileNode(obj_path, changeset=self, mode=stat))

            else:

                raise ChangesetError("Requested object should be Tree "

                                     "or Blob, is %r" % type(obj))

        nodes = dirnodes + filenodes

        for node in nodes:

                self.nodes[node.path] = node

        nodes.sort()

        return nodes

    def get_node(self, path):

        if isinstance(path, unicode):

            path = path.encode('utf-8')

        path = self._fix_path(path)

            try:

                id_ = self._get_id_for_path(path)

            except ChangesetError:

                raise NodeDoesNotExistError("Cannot find one of parents' "

                    "directories for a given path: %s" % path)

        except Exception as e:

            # means it cannot be cloned

            raise urllib2.URLError("[%s] org_exc: %s" % (cleaned_uri, e))

        # now detect if it's proper git repo

        gitdata = resp.read()

            raise urllib2.URLError(

                "url [%s] does not look like an git" % (cleaned_uri))

        return True

    def _get_repo(self, create, src_url=None, update_after_clone=False,

    def _get_url(self, url):

        """

        Returns normalized url. If schema is not given, would fall to

        filesystem (``file:///``) schema.

        """

        url = safe_str(url)

            url = ':///'.join(('file', url))

        return url

    def get_hook_location(self):

        """

        returns absolute path to location where hooks are stored

        Returns ``Node`` object from the given ``path``. If there is no node at

        the given ``path``, ``ChangesetError`` would be raised.

        """

        path = self._fix_path(path)

            if path in self._file_paths:

                node = FileNode(path, changeset=self)

            elif path in self._dir_paths or path in self._dir_paths:

                if path == '':

                    node = RootNode(changeset=self)

                else:

        """

        Returns normalized url. If schema is not given, would fall

        to filesystem

        (``file:///``) schema.

        """

        url = safe_str(url)

            url = "file:" + urllib.pathname2url(url)

        return url

    def get_hook_location(self):

        """

        returns absolute path to location where hooks are stored

    get name of author, or else username.

    It'll try to find an email in the author string and just cut it off

    to get the username

    """

    if not author:

        return ''

        return author

    return author.replace(author_email(author), '').replace('<', '') \

        .replace('>', '').strip()

        >>> parse_changesets('aaabbb..cccddd')

        {'start': 'aaabbb', 'main': None, 'end': 'cccddd'}

    """

    text = text.strip()

    CID_RE = r'[a-zA-Z0-9]+'

        m = re.match(r'^(?P<cid>%s)$' % CID_RE, text)

        if m:

            return {

                'start': None,

                'main': text,

                'end': None,

            assert notification in notifications

            Notification.delete(notification.notification_id)

            Session().commit()

            notifications = Notification.query().all()

            un = UserNotification.query().filter(UserNotification.notification

                                                 == notification).all()

            assert un == []

    def test_delete_association(self):

        parent_group_id=parent_id,

        )

    return RepoGroupModel().update(id_, form_data)

def _update_repo(name, **kwargs):

        kwargs['repo_name'] = name

        kwargs['perms_new'] = []

        kwargs['perms_updates'] = []

    r = RepoModel().update(name, **kwargs)

    return r

class TestRepoGroups(TestController):