Produits Entr'ouvert » w.c.s.

# -*- coding: utf-8 -*-

import shutil

from quixote import cleanup

from wcs.ctl.notify import CmdNotify

from wcs.roles import Role

from utilities import create_temporary_pub

pub = None

def setup_module(module):

    cleanup()

    global pub

    pub = create_temporary_pub()

    pub.cfg['sp'] = {'saml2_providerid': 'test'}

    pub.write_cfg()

    r = Role(name='Service étt civil')

    r.slug = 'service-ett-civil'

    r.store()

def teardown_module(module):

    shutil.rmtree(pub.APP_DIR)

def test_process_notification_wrong_audience():

    notification = {

        '@type': u'provision',

        'audience': [u'coin'],

        'full': True,

        'objects': [

            {

                '@type': 'role',

                'name': u'Service enfance',

                'slug': u'service-enfance',

                'uuid': u'12345',

            },

            {

                '@type': 'role',

                'name': u'Service état civil',

                'slug': u'service-etat-civil',

                'uuid': u'12345',

            },

        ]

    }

    assert Role.count() == 1

    assert Role.select()[0].name == 'Service étt civil'

    assert Role.select()[0].slug == 'service-ett-civil'

    CmdNotify.process_notification(notification)

    assert Role.count() == 1

    assert Role.select()[0].name == 'Service étt civil'

    assert Role.select()[0].slug == 'service-ett-civil'

def test_process_notification():

    notification = {

        '@type': u'provision',

        'audience': [u'test'],

        'full': True,

        'objects': [

            {

                '@type': 'role',

                'name': u'Service enfance',

                'slug': u'service-enfance',

                'uuid': u'12345',

            },

            {

                '@type': 'role',

                'name': u'Service état civil',

                'slug': u'service-ett-civil',

                'uuid': u'xyz',

            },

        ]

    }

    assert Role.count() == 1

    assert Role.select()[0].name == 'Service étt civil'

    assert Role.select()[0].slug == 'service-ett-civil'

    existing_role_id = Role.select()[0].id

    CmdNotify.process_notification(notification)

    assert Role.count() == 2

    old_role = Role.get(existing_role_id)

    assert old_role.name == 'Service état civil'

    assert old_role.slug == 'xyz'

    new_role = Role.get_on_index('12345', 'slug')

    assert new_role.name == 'Service enfance'

    notification = {

        '@type': u'provision',

        'audience': [u'test'],

        'full': True,

        'objects': [

            {

                '@type': 'role',

                'name': u'Service enfance',

                'slug': u'service-enfance',

                'uuid': u'12345',

            },

        ]

    }

    CmdNotify.process_notification(notification)

    assert Role.count() == 1

    assert Role.select()[0].id == new_role.id

    assert Role.select()[0].name == 'Service enfance'

    assert Role.select()[0].slug == '12345'

# w.c.s. - web application for online forms

# Copyright (C) 2005-2014  Entr'ouvert

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, see <http://www.gnu.org/licenses/>.

import os

import sys

import json

from quixote import get_publisher

from wcs.roles import Role

from qommon.ctl import Command

from qommon.publisher import get_cfg

class CmdNotify(Command):

    name = 'notify'

    def execute(self, base_options, sub_options, args):

        self.base_options = base_options

        if sub_options.extra:

            if not self.config.has_section('extra'):

                self.config.add_section('extra')

            for i, extra in enumerate(sub_options.extra):

                self.config.set('extra', 'cmd_line_extra_%d' % i, extra)

        notification = self.load_notification(args)

        if not self.check_valid_notification(notification):

            sys.exit(1)

        import publisher

        publisher.WcsPublisher.configure(self.config)

        pub = publisher.WcsPublisher.create_publisher()

        global_app_dir = pub.app_dir

        for hostname in os.listdir(global_app_dir):

            pub.app_dir = os.path.join(global_app_dir, hostname)

            pub.set_config()

            self.process_notification(notification)

    @classmethod

    def load_notification(cls, args):

        if args[1] == '-':

            # get environment definition from stdin

            return json.load(sys.stdin)

        else:

            return json.load(file(args[1]))

    @classmethod

    def check_valid_notification(cls, notification):

        return isinstance(notification, dict) \

            and '@type' in notification \

            and notification['@type'] in ['provision', 'deprovision'] \

            and 'objects' in notification \

            and 'audience' in notification \

            and isinstance(notification['audience'], list) \

            and isinstance(notification['objects'], list)

    @classmethod

    def process_notification(cls, notification):

        publisher = get_publisher()

        action = notification['@type']

        audience = notification['audience']

        full = notification['full'] if 'full' in notification else False

        # Verify tenant is in audience

        entity_id = get_cfg('sp', {}).get('saml2_providerid')

        if not entity_id or entity_id not in audience:

            return

        uuids = set()

        # Now provision/deprovision

        for o in notification['objects']:

            t = o['@type']

            if t != 'role' \

               or 'uuid' not in o \

               or 'name' not in o \

               or 'slug' not in o:

                continue

            uuid = o['uuid'].encode(publisher.site_charset)

            uuids.add(uuid)

            slug = o['slug'].encode(publisher.site_charset)

            name = o['name'].encode(publisher.site_charset)

            # Find existing role

            try:

                role = Role.get_on_index(uuid, 'slug')

            except KeyError:

                try:

                    role = Role.get_on_index(slug, 'slug')

                except KeyError:

                    # New role

                    if action != 'provision':

                        continue

                    role = Role(name=name)

            if action == 'provision':

                # Provision/rename

                role.name = name

                role.slug = uuid

                role.store()

            elif action == 'deprovision':

                # Deprovision

                role.remove_self()

        # All roles have been sent

        if full:

            for role in Role.select():

                if role.slug not in uuids:

                    role.remove_self()