def test_remove_permission_single(self):
        """Retrait de permission sur un seul groupe."""
        # Permettra de tester une tentative de suppression
        # sur le group3, en ignorant l'accès actuel.
        permissions = commands._permissions.copy()
        permissions[None] = None
        for incode in commands._permissions:
            print "Test permission %s" % incode
            self._set_permissions()
            if incode == "ro":
                group = self._group1
            else:
                group = self._group3

            options = NamespaceStub(
                permission=incode,
                object_type=self._type,
                usergroup=self._usergroup.group_name.encode('utf-8'),
                object_group=group.path.encode('utf-8'),
                batch=False,
                update=False,
                commit=False,   # la base de test est en mémoire,
                                # en la committant, on perdrait tout.
            )
            res = commands.cmd_remove(options)
            self.assertEquals(res, 0)

            # On doit avoir 7 permissions en base :
            # les 8 de départ - 1 permission supprimée.
            dataperms = DBSession.query(tables.DataPermission).all()
            self.assertEquals(7, len(dataperms))

            # On vérifie que la permission qu'on voulait supprimer
            # a effectivement été supprimée.
            dataperm = DBSession.query(tables.DataPermission
                ).filter(tables.DataPermission.idgroup == group.idgroup
                ).filter(tables.DataPermission.idusergroup ==
                    self._usergroup.idgroup
                ).first()
            self.assertEquals(None, dataperm)

            # Suppression des permissions pour le test
            # du type de permission suivant.
            for dataperm in DBSession.query(tables.DataPermission).all():
                DBSession.delete(dataperm)
            DBSession.flush()
            dataperm = DBSession.query(tables.DataPermission).first()
            self.assertEquals(dataperm, None)
    def test_remove_multiple_batch(self):
        """Retrait de permissions sur plusieurs groupes en mode batch."""
        # Permettra de tester une tentative de suppression
        # de toutes les permissions, quelle que soit le type.
        permissions = commands._permissions.copy()
        permissions[None] = None
        for incode in permissions:
            print "Test permission %s" % incode
            self._set_permissions()
            options = NamespaceStub(
                permission=incode,
                object_type=self._type,
                usergroup=self._usergroup.group_name.encode('utf-8'),
                object_group=self._group1.name.encode('utf-8'),
                batch=True,
                update=False,
                commit=False,   # la base de test est en mémoire,
                                # en la committant, on perdrait tout.
            )
            res = commands.cmd_remove(options)
            self.assertEquals(res, 0)

            dataperms = DBSession.query(tables.DataPermission).all()

            if incode is None:
                # Les 4 permissions de l'utilisateur
                # doivent avoir été supprimées.
                # Il reste donc 8-4 permissions en base.
                self.assertEquals(4, len(dataperms))
            else:
                # 2 permissions de l'utilisateur doivent avoir été supprimées.
                # Il en reste donc 8-2 en base.
                self.assertEquals(6, len(dataperms))

            # Suppression des permissions pour le test
            # du type de permission suivant.
            for dataperm in dataperms:
                DBSession.delete(dataperm)
                DBSession.flush()
            dataperm = DBSession.query(tables.DataPermission).first()
            self.assertEquals(dataperm, None)
    def test_remove_multiple_error(self):
        """Pas de retrait de permissions sur plusieurs groupes par défaut."""
        # Permettra de tester une tentative de suppression
        # de toutes les permissions, quelle que soit le type.
        permissions = commands._permissions.copy()
        permissions[None] = None
        for incode in permissions:
            print "Test permission %r" % (incode, )
            self._set_permissions()

            options = NamespaceStub(
                permission=incode,
                object_type=self._type,
                usergroup=self._usergroup.group_name.encode('utf-8'),
                object_group=self._group1.name.encode('utf-8'),
                batch=False,
                update=False,
                commit=False,   # la base de test est en mémoire,
                                # en la committant, on perdrait tout.
            )

            # La commande a été rejetée.
            res = commands.cmd_remove(options)
            self.assertNotEquals(res, 0)

            # Aucune permission n'a été retirée.
            dataperms = DBSession.query(tables.DataPermission).all()
            self.assertEquals(8, len(dataperms))

            # Suppression des permissions pour le test
            # du type de permission suivant.
            for dataperm in DBSession.query(tables.DataPermission).all():
                DBSession.delete(dataperm)
            DBSession.flush()
            dataperm = DBSession.query(tables.DataPermission).first()
            self.assertEquals(dataperm, None)