Example #1
0
    def setUp(self):
        super(AutoCompleterTest, self).setUp()
        # Création d'un environnement WSGI pour les tests.
        # Par défaut, l'utilisateur n'est pas identifé
        # et n'appartient donc à aucun groupe.
        environ = {'repoze.what.credentials': {
                'groups': [],
            }
        }
        request = Request(environ)
        config = VigiloAppConfig('TurboGears')
        config.init_managers_predicate()
        registry = Registry()
        registry.prepare()
        registry.register(tg.request, request)
        registry.register(tg.config, config)
        self.ctrl = AutoCompleteController()

        # Par défaut, l'utilisateur n'est pas identifé.
        tg.request.identity = {'repoze.who.userid': None}

        self.accounts = (
            (u'manager', u'managers'),  # Accès à tout (manager)
            (u'nobody', u'nobody'),     # Accès à rien.
            (u'direct', u'direct'),     # Permissions directe sur l'objet.
            (u'indirect', u'indirect'), # Permissions indirectes sur l'objet.
        )

        # Création des comptes utilisateurs.
        for username, group in self.accounts:
            functions.add_user(username, u'%s@test' % username,
                               u'', u'', group)

        # Création de l'arborescence des objets.
        self.create_deps()
Example #2
0
def populate_DB():
    """ Peuple la base de données en vue des tests. """

    # On crée quatre hôtes de test.
    host1 = functions.add_host(u"host1")
    host2 = functions.add_host(u"host2")
    host3 = functions.add_host(u"host3")
    host4 = functions.add_host(u"host4")
    DBSession.flush()

    # On ajoute un service sur chaque hôte.
    service1 = functions.add_lowlevelservice(host2, u"service1")
    service2 = functions.add_lowlevelservice(host1, u"service2")
    service3 = functions.add_lowlevelservice(host3, u"service3")
    functions.add_lowlevelservice(host4, u"service4")
    DBSession.flush()

    # On crée un groupe de supitems et on y ajoute 'host1' et 'host4' en vue des
    # tests portant sur les permissions
    group1 = functions.add_supitemgroup(u"group1")
    DBSession.add(group1)
    functions.add_host2group(u"host1", u"group1")
    functions.add_host2group(u"host4", u"group1")
    DBSession.flush()

    # On ajoute 2 utilisateurs.
    functions.add_user(u"no_rights", u"*****@*****.**", u"no_rights", u"no_rights", u"no_rights")
    functions.add_user(u"limited_rights", u"*****@*****.**", u"limited_rights", u"limited_rights", u"limited_rights")
    functions.add_usergroup_permission(u"limited_rights", u"vigiboard-silence")
    functions.add_supitemgrouppermission(u"group1", u"limited_rights")
    DBSession.flush()

    # On ajoute 4 règles de mise en silence.
    functions.add_silence(
        states=[u"UNKNOWN"], host=host1, service=None, user=u"manager", comment=u"foo", date=u"2000-01-01 00:00:00"
    )
    functions.add_silence(
        states=[u"DOWN"],
        host=host1,
        service=service2,
        user=u"unrestricted",
        comment=u"bar",
        date=u"2000-01-02 00:00:00",
    )
    functions.add_silence(
        states=[u"WARNING", "CRITICAL"],
        host=host2,
        service=service1,
        user=u"unrestricted",
        comment=u"baz",
        date=u"2000-01-03 00:00:00",
    )
    functions.add_silence(
        states=[u"DOWN"], host=host3, service=None, user=u"manager", comment=u"qux", date=u"2000-01-04 00:00:00"
    )
    DBSession.flush()

    transaction.commit()
    def setUp(self):
        """Initialisation avant chaque test."""
        super(TestDetailsPluginMapsHostLimited, self).setUp()
        # On fait manuellement ce que l'initialisation de VigiMap ferait
        # (car on est dans les tests de VigiBoard, pas ceux de VigiMap).
        root = functions.add_mapgroup(u'Root')
        DBSession.add(Permission(permission_name=u'vigimap-access'))

        print "Creation hote, service et cartes"
        host = functions.add_host(u'localhost éçà')
        functions.add_lowlevelservice(host, u'lls éçà')
        sig = functions.add_supitemgroup(u'supitemgroup éçà')
        functions.add_host2group(host, sig)
        mg = functions.add_mapgroup(u'éçà', root)
        m1 = functions.add_map(u'M1', root)
        # La seconde carte appartient à "/Root/éçà"
        # et permet de tester les accès indirects.
        m2 = functions.add_map(u'M2', mg)
        m3 = functions.add_map(u'M3', root)

        # On ajoute l'hôte 2 fois sur M1 pour vérifier
        # l'absense de doublons dans les liens.
        print "Preparation cartes"
        functions.add_node_host(host, 'h1', m1)
        functions.add_node_host(host, 'h2', m1)
        functions.add_node_host(host, 'h', m2)
        functions.add_node_host(host, 'h', m3)

        # Création de quelques utilisateurs.
        print "Creation des comptes utilisateurs et reglages permissions"
        functions.add_user(u'restricted', u'*****@*****.**',
                           u'restricted', u'restricted',
                           u'restricted')
        functions.add_user(u'unrestricted', u'*****@*****.**',
                           u'unrestricted', u'unrestricted',
                           u'unrestricted')
        functions.add_user(u'no_rights', u'*****@*****.**',
                           u'no_rights', u'no_rights',
                           u'no_rights')
        # Les 3 utilisateurs ont accès à VigiBoard.
        functions.add_usergroup_permission(u'no_rights', u'vigiboard-access')
        functions.add_usergroup_permission(u'restricted', u'vigiboard-access')
        functions.add_usergroup_permission(u'unrestricted', u'vigiboard-access')
        # Mais seuls "restricted" et "unrestricted" ont accès à VigiMap.
        functions.add_usergroup_permission(u'restricted', u'vigimap-access')
        functions.add_usergroup_permission(u'unrestricted', u'vigimap-access')
        # Ils voient tous les trois les événements dans VigiBoard...
        functions.add_supitemgrouppermission(sig, 'no_rights')
        functions.add_supitemgrouppermission(sig, 'restricted')
        functions.add_supitemgrouppermission(sig, 'unrestricted')
        # ... mais "restricted" ne peut voir que "M2" ...
        functions.add_MapGroupPermission(mg, 'restricted')
        # ... tandis que "unrestricted" voit les 3 cartes (par héritage).
        functions.add_MapGroupPermission(root, 'unrestricted')

        DBSession.flush()
        transaction.commit()
Example #4
0
def populateDB():
    """
    Peuple la base de données en ajoutant :
     - 3 groupes d'hôtes ;
     - 3 hôtes ;
     - 3 utilisateurs.
    Les objets construits respectent les matrices suivantes.


    Matrice des utilisateurs et groupes d'utilisateurs :

    +-------------------+-----------+---------------+-------+-----------+
    | util. \ groupe    | managers  | powerusers    | users | visitor   |
    +===================+===========+===============+=======+===========+
    | manager           |     X     |               |       |           |
    +-------------------+-----------+---------------+-------+-----------+
    | poweruser         |           |       X       |       |           |
    +-------------------+-----------+---------------+-------+-----------+
    | user              |           |               |   X   |           |
    +-------------------+-----------+---------------+-------+-----------+
    | visitor           |           |               |       |     X     |
    +-------------------+-----------+---------------+-------+-----------+


    Matrice des groupes d'utilisateurs et des droits
    sur les groupes d'objets supervisés :

    +---------------------------+-----------+-----------+-----------+
    | usergroup \ supitemgroup  |    mhg    |    hg1    |   hg2     |
    |                           |  (host1)  |  (host2)  | (host3)   |
    +===========================+===========+===========+===========+
    | managers                  |    /      |    /      |    /      |
    +---------------------------+-----------+-----------+-----------+
    | powerusers                |    X      |    /      |    /      |
    +---------------------------+-----------+-----------+-----------+
    | users                     |           |    X      |           |
    +---------------------------+-----------+-----------+-----------+
    | visitors                  |           |           |           |
    +---------------------------+-----------+-----------+-----------+
    (X = accès explicite, / = accès implicite)


    @return: Tuple contenant les trois hôtes créés.
    @rtype:  C{tuple} of C{vigilo.models.tables.Host}
    """

    # Ajout d'un groupe d'hôtes principal
    mainhostgroup = add_supitemgroup(u'mhg', None)

    # Ajout d'un premier groupe d'hôtes de second niveau
    hostgroup1 = add_supitemgroup(u'hg1', mainhostgroup)

    # Ajout d'un second groupe d'hôtes de second niveau
    hostgroup2 = add_supitemgroup(u'hg2', mainhostgroup)

    # Ajout de trois hôtes
    # On ajoute des caractères spéciaux pour détecter les
    # conversions implicites Unicode <-> ASCII (et leurs erreurs).
    host1 = add_host(u'host1 éà')
    host2 = add_host(u'host2 éà')
    host3 = add_host(u'host3 éà')

    # Ajout du premier hôte dans le groupe d'hôtes principal.
    add_host2group(host1, mainhostgroup)
    # Ajout du deuxième hôte dans le premier
    # groupe d'hôtes de second niveau.
    add_host2group(host2, hostgroup1)
    # Ajout du troisième hôte dans le second
    # groupe d'hôtes de second niveau.
    add_host2group(host3, hostgroup2)

    # Ajout de trois groupes d'utilisateurs
    poweruser_group = add_usergroup(u'powerusers')
    user_group = add_usergroup(u'users')
    visitor_group = add_usergroup(u'visitor')

    # Ajout de trois utilisateurs
    add_user(u'poweruser', u'*****@*****.**',
        u'Power User', u'poweruserpass', u'powerusers')
    add_user(u'user', u'*****@*****.**',
        u'User', u'userpass', u'users')
    add_user(u'visitor', u'*****@*****.**',
        u'', u'visitorpass', u'visitor')

    # Ajout des permissions sur le groupe d'hôtes
    # principal pour le premier groupe d'utilisateurs
    add_supitemgrouppermission(mainhostgroup, poweruser_group)

    # Ajout des permissions sur le premier groupe d'hôtes
    # secondaire pour le second groupe d'utilisateurs
    add_supitemgrouppermission(hostgroup1, user_group)

    # Ajout de la permission 'vigigraph-access' aux groupes d'utilisateurs
    perm = Permission.by_permission_name(u'vigigraph-access')
    add_usergroup_permission(poweruser_group, perm)
    add_usergroup_permission(user_group, perm)
    add_usergroup_permission(visitor_group, perm)

    return (host1, host2, host3)