Produits Entr'ouvert » Hobo

# Locale and timezone

LANGUAGE_CODE = 'fr-fr'

TIME_ZONE = 'Europe/Paris'

USE_L10N = True

USE_TZ = True

    def __init__(self, *args, **kwargs):

        self.logger = logging.getLogger(__name__)

    def deploy_specifics(self, hobo_environment, tenant):

        # generate SAML keys

    def provision_roles(self, engine, ous):

        roles = get_role_model().objects.all()

        if self.verbosity > 0:

        engine.notify_roles(ous, roles, full=True)

    def provision_users(self, engine, ous, batch_size=512, batch_sleep=30, verbosity=1):

        normal_users = qs.exclude(roles__in=roles_with_attributes)

        if self.verbosity > 0:

        do_provision(normal_users)

        # then those with an admin attribute, use distinct to prevent

        # duplicates caused by join on a m2m relation

        admin_users = qs.filter(roles__in=roles_with_attributes).distinct()

        if self.verbosity > 0:

        do_provision(admin_users)

            )

            all_roles = Role.objects.all().prefetch_related('attributes')

            user_roles = {}

            parents = {}

            for rp in RoleParenting.objects.filter(deleted__isnull=True):

                    if not audience:

                        continue

                    logger.info(

                    )

                    self.notify_agents(

                        {

        elif users:

            audience = [audience for ou in ous.keys() for s, audience in self.get_audience(ou)]

            logger.info(

            )

            self.notify_agents(

                {

                tuple(allowed_technical_roles_prefixes)

            )

        if mode == 'provision':

            self.complete_roles(roles)

                ]

            audience = [entity_id for service, entity_id in self.get_audience(ou)]

            self.notify_agents(

                {

                    '@type': mode,

            self.notify_users(ous, deleted.get(User, []), mode='deprovision')

        except Exception:

            # last step, clear everything

        finally:

            self.threads.discard(threading.current_thread())

        for role in roles:

            role.emails = []

            role.emails_to_members = True

            for attribute in role.attributes.all():

                if attribute.name in ('emails', 'emails_to_members', 'details') and attribute.kind == 'json':

                    setattr(role, attribute.name, json.loads(attribute.value))

        if not isinstance(instance, (User, Role, RoleAttribute, AttributeValue)):

            return

        # ignore last_login update on login

            return

        if isinstance(instance, RoleAttribute):

            instance = instance.role

                    f.write('%s %s ' % (datetime.datetime.now().isoformat(), connection.tenant.domain_url))

                    json.dump(data, f, indent=2)

                    f.write('\n')

                pass

        if getattr(settings, 'HOBO_HTTP_PROVISIONNING', True):

                response = requests.put(sign_url(url, service['secret']), json=data)

                response.raise_for_status()

            except requests.RequestException as e:

            else:

                leftover_audience.remove(audience)

        return leftover_audience

from django.utils.translation import ugettext_lazy as _

    def __init__(self, item_validator):

        self.item_validator = item_validator

        if not value:

            return ''

        if not isinstance(value, str):

        return value

        self.max_length = max_length

        self.min_length = min_length

        item_validators = kwargs.pop('item_validators', [])

        for item_validator in item_validators:

            self.validators.append(ListValidator(item_validator))

                if role_attribute.name in fields:

                    continue

                initial[role_attribute.name] = json.loads(role_attribute.value)

    def save(self, commit=True):

        fields = [x.name for x in Role._meta.get_fields()]

        assert commit

        for field in self.cleaned_data:

            if field in fields:

                continue

class Command(import_template.Command):

    def handle(self, *args, **kwargs):

        try:

        except import_template.UnknownTemplateError:

            # ignore errors if template name contains portal-user or portal-agent as

            # those names do not actually require an existing file to work.

import json

import os

import subprocess

            for tenant in TenantMiddleware.get_tenants():

                try:

                    hobo_environment = tenant.get_hobo_json()

                    continue

                try:

                    me = [x for x in hobo_environment.get('services') if x.get('this') is True][0]

from django.db import migrations, models

from django.db import migrations, models

# Generated by Django 1.11.18 on 2020-07-07 14:56

import django.contrib.postgres.fields

from django.db import migrations, models

class Role(Group):

    uuid = models.CharField(max_length=32, db_index=True)

    emails = ArrayField(models.CharField(max_length=128), default=list)

    emails_to_members = models.BooleanField(default=True)

    def deploy_specifics(self, hobo_environment, tenant):

        me = [x for x in hobo_environment.get('services') if x.get('this')][0]

        if not me.get('secondary'):

        with tenant_context(tenant):

            services = hobo_environment.get('services')

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

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

from celery import Celery

from kombu.common import Broadcast

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

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

import fnmatch

import json

from . import settings

    tenants_dirs = None

    def __init__(self, base_url, title, secret_key, **kwargs):

# Generated by Django 1.11.29 on 2022-01-09 13:16

import django.contrib.postgres.fields.jsonb

import django.db.models.deletion

    return template_vars

    PAGE_CACHE_KEY = 'page-cache'

    def __init__(self, source):

        return get_setting_variable('INTERNAL_IPS.extend')

    def get_initial(self):

        initial['debug_log'] = bool(self.debug_log_variable.json)

        initial['debug_ips'] = self.debug_ips_variable.json

        return initial

        return self.request.META.get('REMOTE_ADDR') or None

    def get_context_data(self, **kwargs):

        ctx['current_ip_debug'] = self.current_ip in self.debug_ips_variable.json

        return ctx

            debug_ips = self.toggle_value(debug_ips, self.current_ip)

        self.debug_ips_variable.json = debug_ips

        self.debug_ips_variable.save()

home = HomeView.as_view()

    )

    def __init__(self, *args, **kwargs):

        self.fields['email_signature'].widget.attrs = {'rows': 4, 'cols': 80}

            smtp.quit()

        finally:

            smtp.close()

        raise ValidationError(

            _('Error while connecting to %(server)s: %(msg)s') % {'server': mx_server, 'msg': e}

        )

class BaseForm(forms.ModelForm):

    def __init__(self, *args, **kwargs):

        choices = self.get_template_choices()

        if len(choices) < 2 or self.instance.id:

            del self.fields['template_name']

        else:

        choices = self.get_template_choices()

        if not self.instance.id and len(choices) == 1:

            self.instance.template_name = choices[0][0]

class AuthenticForm(BaseForm):

        exclude = EXCLUDED_FIELDS

    def __init__(self, *args, **kwargs):

        if not self.instance.is_operational() and not self.initial.get('use_as_idp_for_self'):

            del self.fields['use_as_idp_for_self']

            if self.cleaned_data.get('use_as_idp_for_self'):

                # this idp was just marked as the idp to use, unmark all others

                Authentic.objects.update(use_as_idp_for_self=False)

class WcsForm(BaseForm):

    def __init__(self, service=None, **kwargs):

        self.service = service

    def save(self, commit=True):

        if self.service:

            self.instance.service = self.service

    form_class = None

    success_message = None

    variables = []

    def get_context_data(self, **kwargs):

        if self.request.POST:

            form_data = self.request.POST

        else:

from optparse import make_option

from django.core.management.base import BaseCommand

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

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

import json

import os

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

from django.db import migrations, models

# Generated by Django 1.11.12 on 2019-02-28 10:28

from django.db import migrations

# Generated by Django 1.11.29 on 2021-02-28 09:57

import django.core.validators

from django.db import migrations, models

        return (self.last_operational_check_timestamp - self.last_update_timestamp) < two_minutes

    def as_dict(self):

        as_dict['base_url'] = self.get_base_url_path()

        if self.legacy_urls:

            as_dict['legacy_urls'] = self.legacy_urls

        as_dict['service-id'] = self.Extra.service_id

        as_dict['service-label'] = force_text(self.Extra.service_label)

        as_dict['secondary'] = self.secondary

        if self.get_saml_sp_metadata_url():

            as_dict['saml-sp-metadata-url'] = self.get_saml_sp_metadata_url()

                raise ValidationError(_('This slug is already used. It must be unique.'))

            if service.title == self.title and service.secondary is False and self.secondary is False:

                raise ValidationError(_('This title is already used. It must be unique.'))

    def save(self, *args, **kwargs):

        self.base_url = self.base_url.strip().lower()

            self.secret_key = get_random_string(50, SECRET_CHARS)

        is_new = self.id is None

        if is_new and settings.SERVICE_EXTRA_VARIABLES:

            for variable in settings.SERVICE_EXTRA_VARIABLES.get(self.Extra.service_id, []):

from .models import AVAILABLE_SERVICES, Variable

    def __init__(self, klass):

        self.id = klass.Extra.service_id

        self.label = klass._meta.verbose_name

    template_name = 'environment/home.html'

    def get_context_data(self, **kwargs):

        context['available_services'] = [AvailableService(x) for x in AVAILABLE_SERVICES if x.is_enabled()]

        installed_services = [x for x in utils.get_installed_services() if not x.secondary]

        for service in installed_services:

    template_name = 'environment/variables.html'

    def get_context_data(self, **kwargs):

        context['variables'] = Variable.objects.filter(auto=False, service_pk__isnull=True).order_by('label')

        return context

    form_class = forms.VariableForm

    def get_form_kwargs(self):

        if 'service' in self.kwargs:

            service_id = self.kwargs.pop('service')

            service_slug = self.kwargs.pop('slug')

    success_url = reverse_lazy('environment-home')

    def get_context_data(self, **kwargs):

        context['model_name'] = self.model._meta.verbose_name

        return context

    def get_initial(self):

        initial['base_url'] = utils.create_base_url(

            self.request.build_absolute_uri(), self.model.Extra.service_default_slug

        )

    def get(self, request, *args, **kwargs):

        self.service_id = kwargs.pop('service')

    def post(self, request, *args, **kwargs):

        self.service_id = kwargs.pop('service')

    def get_form_class(self):

        for service in AVAILABLE_SERVICES:

    success_url = reverse_lazy('environment-home')

    def get_context_data(self, **kwargs):

        context['model_name'] = self.model._meta.verbose_name

        return context

    def get(self, request, *args, **kwargs):

        self.service_id = kwargs.pop('service')

        self.get_form_class()

    def post(self, request, *args, **kwargs):

        self.service_id = kwargs.pop('service')

        self.get_form_class()

    def get_form_class(self):

        for service in AVAILABLE_SERVICES:

            return self.form_invalid(form)

        utils.import_parameters(parameters_json)

class ExportView(View):

    required_css_class = 'required'

    def __init__(self, *args, **kwargs):

        self.fields['schema_name'].required = False

    def clean(self):

        from django.template.defaultfilters import slugify

        if not cleaned_data.get('schema_name') and cleaned_data.get('domain_url'):

            cleaned_data['schema_name'] = slugify(cleaned_data['domain_url'])

        return cleaned_data

#

#

#  Copyright 2012 David Strauss <david@davidstrauss.net>

    if CODE_FILE is not None:

        args.append('CODE_FILE=' + CODE_FILE)

    if CODE_LINE is not None:

    if CODE_FUNC is not None:

        args.append('CODE_FUNC=' + CODE_FUNC)

    """

    def __init__(self, level=_logging.NOTSET, sender_function=send, **kwargs):

        for name in kwargs:

            if not _valid_field_name(name):

        warnings.warn(

            'SettingsLogLevel is deprecated, use DEBUG_LOG instead.', DeprecationWarning, stacklevel=2

        )

class RequestContextFilter(logging.Filter):

    def filter(self, record):

        record.levelno = logging.DEBUG

        record.levelname = 'DEBUG'

class LogRecord(logging.LogRecord):

    '''Subclass LogRecord to make multiline log parseable'''

    def getMessage(self):

class TimedRotatingFileHandler(logging.handlers.TimedRotatingFileHandler):

        old_class = record.__class__

        record.__class__ = LogRecord

        try:

        finally:

            record.__class__ = old_class

    '''Filter debug log records based on the DEBUG_LOG setting'''

    def filter(self, record):

            return bool(debug_log)

    def __init__(self, path):

        self.path = path

            return

        if not os.path.exists(debug_log_path):

            return

class ClampLogLevel(logging.Filter):

    def __init__(self, level):

        self.levelname = level.upper()

        self.levelno = getattr(logging, self.levelname)

    def filter(self, record):

        if record.levelno > self.levelno:

            record.levelno = self.levelno

            record.levelname = self.levelname

    """expected Matomo error responses"""

    """api for matomo webservices"""

    def __init__(self):

    success_url = reverse_lazy('matomo-home')

    def get_initial(self):

        initial['tracking_js'] = get_tracking_js()

        return initial

    def form_valid(self, form):

        tracking_js = form.cleaned_data['tracking_js']

        put_tracking_js(tracking_js)

    def get_context_data(self, **kwargs):

        tracking_js = get_tracking_js()

        logme_url = get_variable_value('matomo_logme_url')

        context['logme_url'] = logme_url

    success_url = reverse_lazy('matomo-home')

    def get_initial(self):

        initial['tracking_js'] = get_tracking_js()

        return initial

        put_tracking_js(tracking_js)

        logme_url = get_variable('matomo_logme_url')

        logme_url.delete()

enable_manual = EnableManualView.as_view()

                matomo.create_fake_first_tracking_visit(id_site)

            except MatomoException as exc:

                messages.warning(self.request, 'ping: ' + str(exc))

enable_auto = EnableAutoView.as_view()

        put_tracking_js('')

        variable = get_variable('matomo_logme_url')

        variable.delete()

disable = DisableView.as_view()

from django.conf import settings

    def __init__(self, get_response=None):

        self.get_response = get_response

        if connection.queries_logged:

            sql_queries_count = len(connection.queries)

            requests_queries_count_by_host_view_status_method.labels(

                host_name, view_name, status_code, http_method

            ).observe(sql_queries_count)

from django.utils.module_loading import import_string

    '''Prepend the tenant schema name to the cache prefix'''

    def set_key_prefix(self, prefix):

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

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

import os

import shutil

            # when there are opened files.

            renamed_path = self.path + '.deleted-%s' % time.time()

            os.rename(self.path, renamed_path)

        if renamed_path:

            # remove afterwards and ignore errors (residual directories will

            # have to be cleaned manually)

            try:

                shutil.rmtree(renamed_path)

                pass

    @property

        pass

    def setup(self):

        # make it be always reinitialized

        self.setup_complete = False

    def format_subject(self, subject):

        from .models import Tenant

        try:

            subject = '[%s] %s' % (connection.get_tenant().domain_url, subject)

        except AttributeError:

        """

        Sets option_list and help dynamically.

        """

        app_name = get_commands()[obj.COMMAND_NAME]

        if isinstance(app_name, BaseCommand):

        return obj

    def add_arguments(self, parser):

        parser.add_argument("-d", "--domain", dest="domain")

        # use the privately held reference to the underlying command to invoke

        # the add_arguments path on this parser instance

                self.execute_command(tenant, self.COMMAND_NAME, *args, **options)

    def add_arguments(self, parser):

        parser.add_argument("-d", "--domain", dest="domain", help='specify tenant domain')

    """

    def __new__(cls, *args, **kwargs):

        obj.command_instance = obj.COMMAND()

        return obj

    def add_arguments(self, parser):

        self.command_instance.add_arguments(parser)

    def handle(self, *args, **options):

            hostnames.remove('-')

            hostnames.extend([x.strip() for x in sys.stdin.readlines()])

        # create SP keys for each tenant

        for hostname in hostnames:

from django.core.management.base import BaseCommand

from django.db import connection

        all_tenants = TenantMiddleware.get_tenants()

        for tenant in all_tenants:

                "instead. Please read the documentation if you don't know why you "

                "shouldn't call migrate directly!".format(database)

            )

if django_is_in_test_mode():

    requires_system_checks = []

    def add_arguments(self, parser):

        command = MigrateCommand()

        command.add_arguments(parser)

        parser.set_defaults(verbosity=0)

    def handle(self, *args, **options):

        if self.domain:

            try:

                tenant = TenantMiddleware.get_tenant_by_hostname(self.domain)

            except TenantNotFound:

            else:

                self.run_migrations(tenant, settings.TENANT_APPS)

        elif self.schema_name:

                    app_labels.append(app.label)

            loader = MigrationLoader(None)

            loader.load_disk()

            for tenant in TenantMiddleware.get_tenants():

                connection.set_tenant(tenant, include_public=False)

                applied_migrations = self.get_applied_migrations(app_labels)

        handler.

        """

        use_static_handler = options.get('use_static_handler', True)

        insecure_serving = options.get('insecure_serving', False)

        if use_static_handler and (settings.DEBUG or insecure_serving):

    def handle(self, *args, **kwargs):

        disable_global_logging()

    help = "Show database schema migrations."

    def add_arguments(self, parser):

        command = ShowMigrationsCommand()

        command.add_arguments(parser)

    def handle(self, *args, **options):

        if self.domain:

            try:

                tenant = TenantMiddleware.get_tenant_by_hostname(self.domain)

            except TenantNotFound:

            self.run_showmigrations(tenant, settings.TENANT_APPS)

        else:

            for tenant in TenantMiddleware.get_tenants():

            and not django_is_in_test_mode()

        ):

            raise CommandError(

                "Use sync_schemas instead. Please read the "

                "documentation if you don't know why "

                "you shouldn't call syncdb directly!".format(database)

            )

# this file derive from django-tenant-schemas

#   Author: Bernardo Pires Carneiro

#   Email: carneiro.be@gmail.com

                        print(prefix + msg)

                    continue

                if args_verbosity.verbosity > 1:

                error = run_command_from_argv(klass, args)

                if error:

                    errors.append(error)

import json

import logging

import os

        pass

    def __unicode__(self):

    def __str__(self):

        return 'Tenant %s (%s)' % (self.domain_url, self.schema_name)

    return getattr(import_module(module), attr)

    local = threading.local()

    def __init__(self, default_settings):

from hobo.theme.utils import get_theme

    """

    Base middleware class for loading settings from FILENAME.

    Child classes MUST override update_settings_from_path().

        raise NotImplemented

    def do_update(self, tenant_settings, key, value):

        old_value = getattr(tenant_settings, key, {})

        new_value = old_value.copy()

            break

    def get_new_time(self, tenant):

        return 0

            tenant_settings.MELLON_PRIVATE_KEY = saml_key

    def get_new_time(self, tenant):

        tenant_dir = os.path.join(settings.TENANT_BASE, tenant.domain_url)

        for filename in ['unsecure', 'base_url']:

class CachedLoader(DjangoCachedLoader):

    def cache_key(self, template_name, template_dirs, skip=None):

        if connection.tenant:

            return connection.tenant.domain_url + '-' + key

        return key

                    known_dirnames = (

                        list(

                            itertools.chain(

                                    (

                                        '%s/variants/%s/portal-agent' % (x, theme_value),

                                        '%s/variants/%s' % (x, theme_value),

                                    )

                                    for x in known_dirnames

                            )

                        )

                        + known_dirnames

                    known_dirnames = (

                        list(

                            itertools.chain(

                                    (

                                        '%s/variants/%s/portal-user' % (x, theme_value),

                                        '%s/variants/%s' % (x, theme_value),

                                    )

                                    for x in known_dirnames

                            )

                        )

                        + known_dirnames

import django.core.validators

from django.db import migrations, models

from django.db import migrations

    AttributeDefinition = apps.get_model('profile', 'AttributeDefinition')

    attributes = [

    ]

    for i, attribute_dict in enumerate(attributes):

# Generated by Django 1.11.12 on 2019-01-01 09:46

from django.db import migrations, models

# Generated by Django 1.11.17 on 2020-05-18 18:10

import django.core.validators

from django.db import migrations, models

        ordering = ['order']

    def as_dict(self):

        return as_dict

    def get_real_kind_display(self):

    def save(self, *args, **kwargs):

        if self.order is None:

            self.order = max([0] + [x.order for x in AttributeDefinition.objects.all()]) + 1

class PublikAuthentication(authentication.BaseAuthentication):

    def __init__(self, *args, **kwargs):

        self.logger = logging.getLogger(__name__)

    def resolve_user(self, request):

        User = get_user_model()

    success_url = reverse_lazy('seo-home')

    def get_initial(self):

        initial['meta_description'] = get_variable('meta_description').value

        initial['meta_keywords'] = get_variable('meta_keywords').value

        return initial

    def form_valid(self, form):

        set_variable('meta_description', form.cleaned_data['meta_description'])

        set_variable('meta_keywords', form.cleaned_data['meta_keywords'])

    def get_context_data(self, **kwargs):

        context['robots_txt'] = get_variable('robots_txt').value

        context['mode'] = get_mode(context['robots_txt'])

        return context

    success_url = reverse_lazy('seo-home')

    def get_initial(self):

        initial['content'] = get_variable('robots_txt').value

        return initial

    def form_valid(self, form):

        set_variable('robots_txt', form.cleaned_data['content'])

customize = CustomizeView.as_view()

    template_name = 'hobo/theme_home.html'

    def get_context_data(self, **kwargs):

        def hsv(theme):

            theme_colour = theme.get('variables').get('theme_color') or '#FFFFFF'

            if theme_colour == '#FFFFFF':

                return (1, 1, 1)

            theme_rgb = [int(x, 16) for x in (theme_colour[1:3], theme_colour[3:5], theme_colour[5:])]

            return theme_hsv

        context['themes'] = get_themes()

class DecoratedURLPattern(URLPattern):

    def resolve(self, *args, **kwargs):

        if result:

            result.func = self._decorate_with(result.func)

        return result

class DecoratedRegexURLResolver(URLResolver):

    def resolve(self, *args, **kwargs):

        if result:

            result.func = self._decorate_with(result.func)

        return result

    template_name = 'hobo/home.html'

    def get_context_data(self, **kwargs):

        context['services'] = [x for x in get_installed_services() if not x.secondary]

        context['has_authentic'] = bool(Authentic.objects.filter(secondary=False))

        context['has_global_title'] = Variable.objects.filter(name='global_title').exists()

#! /usr/bin/env python

import glob

import os

def get_version():

    if os.path.exists('VERSION'):

        version = version_file.read()

        version_file.close()

        return version

import json

import os

from io import StringIO

import pytest

from django.contrib.auth.models import User

from django.contrib.contenttypes.models import ContentType

from django.core.management.base import CommandError

from hobo.environment.management.commands.cook import Command

from hobo.environment.models import (

    """no exception raised if url are available"""

    command = Command()

    command.server_action = 'mock a server_action handler (ex: hobo-create)'

    monkeypatch.setattr(ServiceBase, 'is_resolvable', lambda x: True)

    monkeypatch.setattr(ServiceBase, 'has_valid_certificate', lambda x: True)

    """raise CommandError"""

    command = Command()

    command.server_action = 'mock a server_action handler (ex: hobo-create)'

    monkeypatch.setattr(ServiceBase, 'is_resolvable', lambda x: True)

    monkeypatch.setattr(ServiceBase, 'has_valid_certificate', lambda x: True)

    """raise CommandError"""

    command = Command()

    command.server_action = 'mock a server_action handler (ex: hobo-create)'

    monkeypatch.setattr(ServiceBase, 'is_resolvable', lambda x: False)

    monkeypatch.setattr(ServiceBase, 'has_valid_certificate', lambda x: True)

    """raise CommandError"""

    command = Command()

    command.server_action = 'mock a server_action handler (ex: hobo-create)'

    monkeypatch.setattr(ServiceBase, 'is_resolvable', lambda x: True)

    monkeypatch.setattr(ServiceBase, 'has_valid_certificate', lambda x: False)

        handler.write(json.dumps(recipe))

    command.run_cook(recipe_path)

    assert mocked_notify_agents.mock_calls == []

    assert command.wait_operationals.mock_calls == [call(timeout=42)]

        handler.write(json.dumps(recipe))

    command.run_cook(recipe_path)

def test_load_variables_from(db, tmpdir):

        handler.write(json.dumps(recipe))

    command.run_cook(recipe_path)

def test_wait_operationals(db, monkeypatch):

    with patch('hobo.environment.management.commands.cook.open', mocked_open, create=True):

        command.create_hobo('http://entrouvert.org/and_much')

    assert command.create_site.mock_calls == [

    ]

    assert mocked_call_command.mock_calls == []

    assert len(mocked_connection.set_tenant.mock_calls) == 1

import smtplib

import socket

import threading

import dns.resolver

import pytest

from django.core.exceptions import ValidationError

from django.utils.encoding import force_text

import json

import pytest

    with pytest.raises(ValidationError) as e:

        passerelle.clean()

def test_unique_title():

    with pytest.raises(ValidationError) as e:

        combo.clean()

    # secondary services can be added

    combo.secondary = True

import json

import socket

import pytest

import requests

from django.core.cache import cache

from django.utils import timezone

from httmock import HTTMock, remember_called, urlmatch

from hobo.environment.models import Authentic, Combo

import os

import sys

from io import StringIO

import pytest

from requests import Response, exceptions