from pylons.i18n import ugettext as _, lazy_ugettext as l_

from sqlalchemy import asc

from sqlalchemy.sql import func

from repoze.what.predicates import Any, All, in_group, \

                                    has_permission, not_anonymous, \

                                    NotAuthorizedError

from vigilo.models.tables import Event, EventHistory, CorrEvent, Host, \

                                    SupItem, SupItemGroup, LowLevelService, \

                                    StateName, State

from vigilo.models.functions import sql_escape_like

from vigilo.models.tables.secondary_tables import EVENTSAGGREGATE_TABLE

        # Application des filtres si nécessaire

        if supitemgroup:

        if host:

            search['host_'] = host

            host = sql_escape_like(host)

        if service:

            search['service'] = service

            service = sql_escape_like(service)

        if output:

            search['output'] = output

            output = sql_escape_like(output)

        if trouble_ticket:

            search['tt'] = trouble_ticket

            trouble_ticket = sql_escape_like(trouble_ticket)

        if from_date:

            search['from_date'] = from_date.lower()

            else:

                aggregates.add_filter(CorrEvent.timestamp_active <= to_date)

        # Calcul des éléments à afficher et du nombre de pages possibles

        total_rows = aggregates.num_rows()

        items_per_page = int(config['vigiboard_items_per_page'])

        if parent_id is None:

            return self.get_root_host_groups()

        # On vérifie si le groupe parent fait partie des

        # groupes auxquel l'utilisateur a accès, et on

        # retourne une liste vide dans le cas contraire

        is_manager = in_group('managers').is_met(request.environ)

        # On récupère la liste des groupes dont

        # l'identifiant du parent est passé en paramètre

        db_groups = DBSession.query(

            SupItemGroup

        ).order_by(SupItemGroup.name.asc())

        groups = []

        for group in db_groups.all():

            groups.append({

        @rtype : C{dict} of C{list} of C{dict} of C{mixed}

        """

        # On filtre ces groupes racines afin de ne

        # retourner que ceux auquels l'utilisateur a accès

        user = get_current_user()

        is_manager = in_group('managers').is_met(request.environ)

        if not is_manager:

        groups = []

            groups.append({

                'id'   : group.idgroup,

                'name' : group.name,

        Retourne le nombre de lignes de la requête.

        Si celle-ci n'est pas encore générée, on le fait.

        """

        self.generate_request()

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

                            Permission, DataPermission, StateName, \

                            LowLevelService, Event, CorrEvent, Host

def insert_deps(return_service):

    """

    """

    timestamp = datetime.now()

    host = Host(

        name=u'bar',

    hostgroup.supitems.append(host)

    DBSession.flush()

    service = LowLevelService(

        host=host,

                'idcorrevent': idcorrevent,

                'plugin_name': 'details',

            }, status=401)

from vigilo.models.session import DBSession

from vigilo.models.tables import Permission, DataPermission, StateName, \

                            Event, CorrEvent, ImpactedPath, ImpactedHLS, \

                            User, UserGroup

from vigiboard.tests import TestController

def populate_DB():

    """ Peuple la base de données. """

    # On ajoute un groupe d'hôtes

    # On lui octroie les permissions

    usergroup = UserGroup.by_group_name(u'users_with_access')

    # On crée un hôte de test.

    host = Host(

        checkhostcmd = u'halt',

        snmpcommunity = u'public',

        hosttpl = u'/dev/null',

    # On ajoute un évènement corrélé causé par cet évènement 'brut'.

    aggregate = CorrEvent(

        timestamp_active = datetime.now(),

        priority = 1,

        status = u'None')

    aggregate.events.append(event1)

    DBSession.add(aggregate)

    DBSession.flush()

    transaction.commit()

    return aggregate

def add_paths(path_number, path_length, idsupitem):

    Ajoute path_number chemins de services de haut niveau impactés

    dans la base de donnée. Leur longeur sera égale à path_length.

    La 3ème valeur passée en paramètre est l'id du supitem impactant.

    haut niveau sont créés dans l'opération.

    """

    # Création des chemins de services de haut niveau impactés.

    for j in range(path_number):

        # On crée le chemin en lui-même

        path = ImpactedPath(idsupitem = idsupitem)

        DBSession.add(path)

        DBSession.flush()

        # Pour chaque étage du chemin,

        for i in range(path_length):

            # on ajoute un service de haut niveau dans la BDD,

            hls = HighLevelService(

                **hls_template)

            DBSession.add(hls)

            DBSession.add(

                ImpactedHLS(

                    path = path,

                    hls = hls,

                    distance = i + 1,

                    ))

    DBSession.flush()

    transaction.commit()

class TestHLSPlugin(TestController):

    """

    de haut niveau impactés par un évènement corrélé.

    """

    def setUp(self):

        Teste la valeur de retour du plugin lorsque

        aucun service de haut niveau n'est impacté.

        """

        # On peuple la base de données avant le test.

        DBSession.add(self.aggregate)

        add_paths(0, 0, self.aggregate.events[0].idsupitem)

        DBSession.add(self.aggregate)

        ### 1er cas : l'utilisateur n'est pas connecté.

        # On vérifie que le plugin retourne bien une erreur 401.

        resp = self.app.post(

            {"idcorrevent" : str(self.aggregate.idcorrevent),

             "plugin_name" : "hls"},

            status = 401,)

        ### 2ème cas : l'utilisateur n'a pas les

        ### droits sur l'hôte ayant causé le correvent.

        # On vérifie que le plugin retourne bien une erreur 404.

        resp = self.app.post(

            {"idcorrevent" : str(self.aggregate.idcorrevent),

             "plugin_name" : "hls"},

            status = 404,

            extra_environ={'REMOTE_USER': 'no_access'})

        ### 3ème cas : l'utilisateur a cette fois les droits.

        resp = self.app.post(

            {"idcorrevent" : str(self.aggregate.idcorrevent),

             "plugin_name" : "hls"},

            extra_environ={'REMOTE_USER': 'access'})

        # On vérifie que le plugin ne retourne toujours rien.

        assert_equal(resp.json, {"services": []})

    def test_1_impacted_hls_path(self):

        """

        Retour du plugin HLS pour 1 chemin impacté

        Teste la valeur de retour du plugin lorsqu'un

        chemin de services de haut niveau est impacté.

        """

        # On peuple la base de données avant le test.

        DBSession.add(self.aggregate)

        add_paths(1, 2, self.aggregate.events[0].idsupitem)

        DBSession.add(self.aggregate)

        ### 1er cas : l'utilisateur n'est pas connecté.

        # On vérifie que le plugin retourne bien une erreur 401.

        resp = self.app.post(

            {"idcorrevent" : str(self.aggregate.idcorrevent),

             "plugin_name" : "hls"},

            status = 401,)

        ### 2ème cas : l'utilisateur n'a pas les droits

        ### sur l'hôte ayant causé le correvent, on doit

        ### obtenir une erreur 404 (pas d'événement trouvé

        ### avec les informations liées à cet utilisateur).

        resp = self.app.post(

            {"idcorrevent" : str(self.aggregate.idcorrevent),

             "plugin_name" : "hls"},

            status = 404,

            extra_environ={'REMOTE_USER': 'no_access'})

        ### 3ème cas : l'utilisateur a cette fois les droits.

        resp = self.app.post(

            {"idcorrevent" : str(self.aggregate.idcorrevent),

             "plugin_name" : "hls"},

            extra_environ={'REMOTE_USER': 'access'})

        # On vérifie que le plugin retourne bien les 2 HLS impactés.

        assert_equal(resp.json, {"services": ['HLS12']})

    def test_2_impacted_hls_path(self):

        """

        Retour du plugin HLS pour 2 chemins impactés

        Teste la valeur de retour du plugin lorsque deux

        chemins de services de haut niveau sont impactés.

        """

        # On peuple la base de données avant le test.

        DBSession.add(self.aggregate)

        add_paths(2, 2, self.aggregate.events[0].idsupitem)

        DBSession.add(self.aggregate)

        ### 1er cas : l'utilisateur n'est pas connecté.

        # On vérifie que le plugin retourne bien une erreur 401.

        resp = self.app.post(

            {"idcorrevent" : str(self.aggregate.idcorrevent),

             "plugin_name" : "hls"},

            status = 401,)

        ### 2ème cas : l'utilisateur n'a pas les

        ### droits sur l'hôte ayant causé le correvent.

        resp = self.app.post(

            {"idcorrevent" : str(self.aggregate.idcorrevent),

             "plugin_name" : "hls"},

            status = 404,

            extra_environ={'REMOTE_USER': 'no_access'})

        ### 3ème cas : l'utilisateur a cette fois les droits.

        resp = self.app.post(

            {"idcorrevent" : str(self.aggregate.idcorrevent),

             "plugin_name" : "hls"},

            extra_environ={'REMOTE_USER': 'access'})

        # On vérifie que le plugin retourne bien les 4 HLS impactés.

        assert_equal(resp.json, {"services": ['HLS12', 'HLS22']})

from vigilo.models.session import DBSession

from vigilo.models.tables import Event, CorrEvent, DataPermission, \

                            LowLevelService, User, UserGroup, Permission

from vigiboard.tests import TestController

def populate_DB():

    """ Peuple la base de données. """

    # On ajoute les groupes et leurs dépendances

    usergroup = UserGroup.by_group_name(u'users_with_access')

    DBSession.add(DataPermission(

        rows = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr')

        print "There are %d rows in the result set" % len(rows)

        assert_equal(len(rows), 1)

from vigilo.models.session import DBSession

from vigilo.models.tables import Event, EventHistory, CorrEvent, \

                            Permission, StateName, Host, \

                            Permission, DataPermission, User, \

from vigiboard.tests import TestController

def populate_DB():

    """ Peuple la base de données. """

    # On ajoute un groupe d'hôtes et un groupe de services.

    usergroup = UserGroup.by_group_name(u'users_with_access')

    DBSession.add(DataPermission(

    # On crée un hôte de test, et on l'ajoute au groupe d'hôtes.

    managerhost = Host(

        checkhostcmd = u'halt',

        snmpcommunity = u'public',

        hosttpl = u'/dev/null',

    DBSession.add(managerservice)

    supitemmanagers.supitems.append(managerservice)

    DBSession.flush()

    return (managerhost, managerservice)

def add_correvent_caused_by(supitem):

    """

    par un incident survenu sur l'item passé en paramètre.

    Génère un historique pour les tests.

    """

    # Ajout d'un événement

    event = Event(

        message = u'foo',

        current_state = StateName.statename_to_value(u"WARNING"),

        timestamp = datetime.now(),

    # Ajout des historiques

    DBSession.add(EventHistory(

        type_action=u'Nagios update state',

        timestamp=datetime.now()))

    DBSession.add(EventHistory(

        type_action=u'Acknowlegement change state',

        timestamp=datetime.now()))

    DBSession.flush()

    # Ajout d'un événement corrélé

    aggregate = CorrEvent(

        timestamp_active = datetime.now(),

        priority = 1,

        status = u"None")

    aggregate.events.append(event)

    DBSession.add(aggregate)

    DBSession.flush()

    return event.idevent

class TestHistoryTable(TestController):

    """

        # On peuple la BDD avec un hôte, un service de bas niveau,

        # et un groupe d'hôtes et de services associés à ces items.

        (managerhost, managerservice) = populate_DB()

        # On ajoute un évènement corrélé causé par l'hôte

        idevent = add_correvent_caused_by(managerhost)

        transaction.commit()

        # L'utilisateur N'A PAS les bonnes permissions.

        environ = {'REMOTE_USER': 'limited_access'}

        # On s'attend à ce qu'une erreur 302 soit renvoyée, et à

        # ce qu'un message d'erreur précise à l'utilisateur qu'il

        # n'a pas accès aux informations concernant cet évènement.

        response = self.app.get(

            '/event/%d' % idevent,

            extra_environ = environ)

        # On suit la redirection.

        # L'utilisateur a les bonnes permissions.

        environ = {'REMOTE_USER': 'access'}

        # On s'attend à ce que le statut de la requête soit 200.

        response = self.app.get(

            '/event/%d' % idevent,

            extra_environ = environ)

        # Il doit y avoir 2 lignes de résultats.

        # On peuple la BDD avec un hôte, un service de bas niveau,

        # et un groupe d'hôtes et de services associés à ces items.

        (managerhost, managerservice) = populate_DB()

        # On ajoute un évènement corrélé causé par le service

        idevent = add_correvent_caused_by(managerservice)

        transaction.commit()

        # L'utilisateur n'est pas authentifié.

        # L'utilisateur N'A PAS les bonnes permissions.

        environ = {'REMOTE_USER': 'limited_access'}

        # On s'attend à ce qu'une erreur 302 soit renvoyée, et à

        # ce qu'un message d'erreur précise à l'utilisateur qu'il

        # n'a pas accès aux informations concernant cet évènement.

        response = self.app.get(

            '/event/%d' % idevent,

            extra_environ = environ)

        # On suit la redirection.

        # L'utilisateur a les bonnes permissions.

        environ = {'REMOTE_USER': 'access'}

        # On s'attend à ce que le statut de la requête soit 200.

        response = self.app.get(

            '/event/%d' % idevent,

            extra_environ = environ)

        # Il doit y avoir 2 lignes de résultats.

        rows = response.lxml.xpath(

            '//table[contains(@class,"vigitable")]/tbody/tr')

        assert_equal(len(rows), 2)

from vigilo.models.tables import Event, EventHistory, CorrEvent, User, \

                            Permission, StateName, Host, UserGroup, \

                            LowLevelService, SupItemGroup, DataPermission

from vigiboard.tests import TestController

def populate_accounts():

def populate_DB(caused_by_service):

    """ Peuple la base de données. """

    # On ajoute un groupe d'hôtes et un groupe de services.

    usergroup = UserGroup.by_group_name(u'users_with_access')

    DBSession.add(DataPermission(

from vigilo.models.session import DBSession

from vigilo.models.tables import Event, EventHistory, CorrEvent, User, \

                            Permission, StateName, Host, UserGroup, \

from vigiboard.tests import TestController

def populate_DB():

    """ Peuple la base de données. """

    # On ajoute un groupe d'hôtes et un groupe de services.

    DBSession.add(supitemmanagers)

    DBSession.flush()

    # On crée un 2 hôtes, et on les ajoute au groupe d'hôtes.

    host1 = Host(

        checkhostcmd = u'halt',

        snmpcommunity = u'public',

        hosttpl = u'/dev/null',

    DBSession.add(host1)

    supitemmanagers.supitems.append(host1)

    host2 = Host(

        checkhostcmd = u'halt',

        snmpcommunity = u'public',

        hosttpl = u'/dev/null',

    DBSession.add(service2)

    supitemmanagers.supitems.append(service2)

    DBSession.flush()

    return ([host1, host2], [service1, service2])

def add_correvent_caused_by(supitem, timestamp,

        correvent_status=u"None", event_status=u"WARNING"):

    """

    par un incident survenu sur l'item passé en paramètre.

    Génère un historique pour les tests.

    """

    # Ajout d'un événement

    event = Event(

        message = u'foo',

        current_state = StateName.statename_to_value(event_status),

        timestamp = datetime.now(),

    # Ajout d'un événement corrélé

    aggregate = CorrEvent(

        timestamp_active = timestamp,

        priority = 1,

        status = correvent_status)

    aggregate.events.append(event)

    DBSession.add(aggregate)

    DBSession.flush()

    return aggregate.idcorrevent

        # On peuple la BDD avec 2 hôtes, 2 services de bas niveau,

        # et un groupe d'hôtes et de services associés à ces items.

        (hosts, services) = populate_DB()

        # On ajoute 2 évènements corrélés causés par ces hôtes

        timestamp = datetime.now()

        correvent1_id = add_correvent_caused_by(hosts[0], timestamp)

        correvent2_id = add_correvent_caused_by(hosts[1], timestamp)

        transaction.commit()

        ### 1er cas : L'utilisateur n'est pas connecté.

        # On vérifie que le plugin retourne bien une erreur 401.

        response = self.app.post(

                "trouble_ticket" : u"foo",

                "ack" : u'NoChange',

            }, status = 401)

        ### 2ème cas : L'utilisateur utilisé pour

        # se connecter à Vigiboard est 'limited_access'.

        environ = {'REMOTE_USER': 'limited_access'}

        # On s'attend à ce qu'une erreur 302 soit renvoyée, et à

        # ce qu'un message d'erreur précise à l'utilisateur qu'il

        # n'a pas la permission de modifier ces évènements.

                "trouble_ticket" : u"foo",

                "last_modification": mktime(timestamp.timetuple()),

            }, status = 302, extra_environ = environ)

        response = response.follow(status=200, extra_environ = environ)

        assert_true(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="error"]'))

        ### 3ème cas : L'utilisateur utilisé pour

        # se connecter à Vigiboard est 'access'.

        environ = {'REMOTE_USER': 'access'}

        # On s'attend à ce que le statut de la requête soit 302,

        # et à ce qu'un message informe l'utilisateur que les

        # évènements corrélés sélectionnées ont bien été mis à jour.

                "trouble_ticket" : u"foo",

                "ack" : u'NoChange',

            }, status = 302, extra_environ = environ)

        response = response.follow(status=200, extra_environ = environ)

        assert_false(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="error"]'))

        assert_true(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="ok"]'))

        # On s'assure que le ticket de l'évènement corrélé

        # a bien été mis à jour dans la base de données.

        correvents = DBSession.query(

            CorrEvent.trouble_ticket

            ).filter(CorrEvent.idcorrevent.in_([correvent1_id, correvent2_id])

            ).all()

        assert_equal(correvents[0].trouble_ticket, u"foo")

        assert_equal(correvents[1].trouble_ticket, u"foo")

        # On peuple la BDD avec 2 hôtes, 2 services de bas niveau,

        # et un groupe d'hôtes et de services associés à ces items.

        (hosts, services) = populate_DB()

        # On ajoute 2 évènements corrélés causés par ces hôtes

        timestamp = datetime.now()

        correvent1_id = add_correvent_caused_by(services[0], timestamp)

        correvent2_id = add_correvent_caused_by(services[1], timestamp)

        transaction.commit()

        ### 1er cas : L'utilisateur n'est pas connecté.

        # On vérifie que le plugin retourne bien une erreur 401.

        response = self.app.post(

                "trouble_ticket" : u"foo",

                "ack" : u'NoChange',

            }, status = 401)

        ### 2ème cas : L'utilisateur utilisé pour

        # se connecter à Vigiboard est 'limited_access'.

        environ = {'REMOTE_USER': 'limited_access'}

        # On s'attend à ce qu'une erreur 302 soit renvoyée, et à

        # ce qu'un message d'erreur précise à l'utilisateur qu'il

        # n'a pas la permission de modifier ces évènements.

                "trouble_ticket" : u"foo",

                "ack" : u'NoChange',

            }, status = 302, extra_environ = environ)

        response = response.follow(status=200, extra_environ = environ)

        assert_true(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="error"]'))

        ### 3ème cas : L'utilisateur utilisé pour

        # se connecter à Vigiboard est 'access'.

        environ = {'REMOTE_USER': 'access'}

        # On s'attend à ce que le statut de la requête soit 302,

        # et à ce qu'un message informe l'utilisateur que les

        # évènements corrélés sélectionnées ont bien été mis à jour.

                "trouble_ticket" : u"foo",

                "ack" : u'NoChange',

            }, status = 302, extra_environ = environ)

        response = response.follow(status=200, extra_environ = environ)

        assert_false(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="error"]'))

        assert_true(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="ok"]'))

        # On s'assure que le ticket de l'évènement corrélé

        # a bien été mis à jour dans la base de données.

        correvents = DBSession.query(

        # On peuple la BDD avec 2 hôtes, 2 services de bas niveau,

        # et un groupe d'hôtes et de services associés à ces items.

        (hosts, services) = populate_DB()

        # On ajoute 2 évènements corrélés causés par ces hôtes

        timestamp = datetime.now()

        correvent1_id = add_correvent_caused_by(hosts[0], timestamp)

        correvent2_id = add_correvent_caused_by(hosts[1], timestamp)

        transaction.commit()

        ### 1er cas : L'utilisateur n'est pas connecté.

        # On vérifie que le plugin retourne bien une erreur 401.

        response = self.app.post(

                "trouble_ticket" : "",

                "ack" : u'Acknowledged',

            }, status = 401)

        ### 2ème cas : L'utilisateur utilisé pour

        # se connecter à Vigiboard est 'limited_access'.

        environ = {'REMOTE_USER': 'limited_access'}

        # On s'attend à ce qu'une erreur 302 soit renvoyée, et à

        # ce qu'un message d'erreur précise à l'utilisateur qu'il

        # n'a pas la permission de modifier ces évènements.

                "trouble_ticket" : "",

                "ack" : u'Acknowledged',

            }, status = 302, extra_environ = environ)

        response = response.follow(status=200, extra_environ = environ)

        assert_true(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="error"]'))

        ### 3ème cas : L'utilisateur utilisé pour

        # se connecter à Vigiboard est 'access'.

        environ = {'REMOTE_USER': 'access'}

        # On s'attend à ce que le statut de la requête soit 302,

        # et à ce qu'un message informe l'utilisateur que les

        # évènements corrélés sélectionnées ont bien été mis à jour.

                "trouble_ticket" : "",

                "ack" : u'Acknowledged',

            }, status = 302, extra_environ = environ)

        response = response.follow(status=200, extra_environ = environ)

        assert_false(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="error"]'))

        assert_true(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="ok"]'))

        # On s'assure que le statut de l'évènement corrélé

        # a bien été mis à jour dans la base de données.

        correvents = DBSession.query(

        # On peuple la BDD avec 2 hôtes, 2 services de bas niveau,

        # et un groupe d'hôtes et de services associés à ces items.

        (hosts, services) = populate_DB()

        # On ajoute 2 évènements corrélés causés par ces hôtes

        timestamp = datetime.now()

        correvent1_id = add_correvent_caused_by(services[0], timestamp)

        correvent2_id = add_correvent_caused_by(services[1], timestamp)

        transaction.commit()

        ### 1er cas : L'utilisateur n'est pas connecté.

        # On vérifie que le plugin retourne bien une erreur 401.

        response = self.app.post(

                "trouble_ticket" : "",

                "ack" : u'Acknowledged',

            }, status = 401)

        ### 2ème cas : L'utilisateur utilisé pour

        # se connecter à Vigiboard est 'limited_access'.

        environ = {'REMOTE_USER': 'limited_access'}

        # On s'attend à ce qu'une erreur 302 soit renvoyée, et à

        # ce qu'un message d'erreur précise à l'utilisateur qu'il

        # n'a pas la permission de modifier ces évènements.

                "trouble_ticket" : "",

                "ack" : u'Acknowledged',

            }, status = 302, extra_environ = environ)

        response = response.follow(status=200, extra_environ = environ)

        assert_true(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="error"]'))

        ### 3ème cas : L'utilisateur utilisé pour

        # se connecter à Vigiboard est 'access'.

        environ = {'REMOTE_USER': 'access'}

        # On s'attend à ce que le statut de la requête soit 302,

        # et à ce qu'un message informe l'utilisateur que les

        # évènements corrélés sélectionnées ont bien été mis à jour.

                "trouble_ticket" : "",

                "ack" : u'Acknowledged',

            }, status = 302, extra_environ = environ)

        response = response.follow(status=200, extra_environ = environ)

        assert_false(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="error"]'))

        assert_true(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="ok"]'))

        # On s'assure que le statut de l'évènement corrélé

        # a bien été mis à jour dans la base de données.

        correvents = DBSession.query(

        # On peuple la BDD avec 2 hôtes, 2 services de bas niveau,

        # et un groupe d'hôtes et de services associés à ces items.

        (hosts, services) = populate_DB()

        # On ajoute 2 évènements corrélés causés par ces hôtes

        timestamp = datetime.now()

        correvent1_id = add_correvent_caused_by(services[0], timestamp)

        correvent2_id = add_correvent_caused_by(services[1], timestamp)

        later_date = datetime.now()

        # Date du chargement de la page

        date = mktime(later_date.timetuple()) - 42

        # On ajoute une entrée dans l'historique de l'évènement brut

        # causant le premier évènement corrélé, portant pour timestamp

        # une date postérieure à celle du chargement de la page.

            idevent = correvent1.idcause,

            timestamp = later_date))

        DBSession.flush()

        transaction.commit()

        # L'utilisateur utilisé pour se connecter à Vigiboard est 'access'.

        environ = {'REMOTE_USER': 'access'}

        # On s'attend à ce que le statut de la requête soit 302, et

        # à ce qu'un message d'erreur avise l'utilisateur que des

        # changements sont intervenus depuis le chargement de la page.

                "trouble_ticket" : "",

                "ack" : u'Acknowledged',

            }, status = 302, extra_environ = environ)

        response = response.follow(status=200, extra_environ = environ)

        assert_true(response.lxml.xpath(

            '//div[@id="flash"]/div[@class="warning"]'))

        # On s'assure que le statut de l'évènement corrélé

        # n'a pas été modifié dans la base de données.

        status = DBSession.query(

            ).filter(CorrEvent.idcorrevent == correvent1_id

            ).scalar()

        assert_equal(status, u'None')

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

                                    Event, CorrEvent, StateName, \

                                    User, UserGroup, DataPermission

def insert_deps():

    """Insère les dépendances nécessaires aux tests."""

    timestamp = datetime.now()

    host = Host(

        name=u'bar',

        cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')

        print "There are %d columns in the result set" % len(cols)

        assert_equal(len(cols), 1)

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

                                    Event, CorrEvent, StateName, \

                                    User, UserGroup, DataPermission

def insert_deps():

    """Insère les dépendances nécessaires aux tests."""

    DBSession.add(host)

    DBSession.flush()

    hostgroup.supitems.append(host)

    event = Event(

        supitem=host,

        cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')

        print "There are %d columns in the result set" % len(cols)

        assert_true(len(cols) > 1)

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

                                    StateName, LowLevelService, \

                                    Event, CorrEvent, User, UserGroup, \

                                    DataPermission

def insert_deps():

    """Insère les dépendances nécessaires aux tests."""

    timestamp = datetime.now()

    host = Host(

        name=u'bar',

    hostgroup.supitems.append(host)

    DBSession.flush()

    DBSession.add(servicegroup)

    DBSession.flush()

        cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')

        print "There are %d columns in the result set" % len(cols)

        assert_equal(len(cols), 1)

from vigiboard.tests import TestController

from vigilo.models.session import DBSession

                                    Event, CorrEvent, User, UserGroup, \

                                    DataPermission

def insert_deps():

    """Insère les dépendances nécessaires aux tests."""

    timestamp = datetime.now()

    host = Host(

        name=u'bar',

        cols = response.lxml.xpath('//table[@class="vigitable"]/tbody/tr/td')

        print "There are %d columns in the result set" % len(cols)

        assert_equal(len(cols), 1)

[plugin:sqlauth]

use = vigilo.turbogears.repoze_plugins:auth_plugin

[general]

request_classifier = vigilo.turbogears.repoze_plugins:vigilo_api_classifier

challenge_decider = repoze.who.classifiers:default_challenge_decider

[identifiers]

plugins =