def setUp(self):
     super(AccessRuleTestCase, self).setUp()
     self.activate_extensions('radicale')
     populate_database()
     self.rights_file_path = tempfile.mktemp()
     parameters.save_admin(
         "RIGHTS_FILE_PATH", self.rights_file_path, app="radicale")

 def setUpTestData(cls):
     """Create test data."""
     super(AliasAPITestCase, cls).setUpTestData()
     parameters.save_admin("ENABLE_ADMIN_LIMITS", "no", app="limits")
     factories.populate_database()
     cls.da_token = Token.objects.create(
         user=core_models.User.objects.get(username="[email protected]"))

 def setUpTestData(cls):
     """Create test data."""
     super(APIDomainLimitsTestCase, cls).setUpTestData()
     parameters.save_admin("ENABLE_DOMAIN_LIMITS", "yes")
     for name, tpl in utils.get_domain_limit_templates():
         parameters.save_admin(
             "DEFLT_DOMAIN_{}_LIMIT".format(name.upper()), 2)
     populate_database()

    def setUp(self):
        super(LimitsTestCase, self).setUp()

        for tpl in LimitTemplates().templates:
            parameters.save_admin("DEFLT_{0}".format(tpl[0].upper()), 2, app="limits")
        self.user = UserFactory.create(username="reseller", groups=("Resellers",))
        self.clt.logout()
        self.clt.login(username="reseller", password="toto")

def unset_default_topredirection(extension):
    """
    Simple callback to change the default redirection if the
    corresponding extension is being disabled.
    """
    topredirection = parameters.get_admin("DEFAULT_TOP_REDIRECTION")
    if topredirection == extension.name:
        parameters.save_admin("DEFAULT_TOP_REDIRECTION", "userprefs")

 def setUpTestData(cls):
     """Custom setUpTestData method."""
     super(ResourceTestCase, cls).setUpTestData()
     for name, tpl in utils.get_limit_templates():
         parameters.save_admin(
             "DEFLT_{0}_LIMIT".format(name.upper()), 2,
             app="limits"
         )
     populate_database()

 def setUpTestData(cls):
     """Custom setUpTestData method."""
     super(ResourceTestCase, cls).setUpTestData()
     for tpl in LimitTemplates().templates:
         parameters.save_admin(
             "DEFLT_{0}".format(tpl[0].upper()), 2,
             app="limits"
         )
     populate_database()

    def setUp(self):
        """Custom setUp method.

        The 'limits' is manually loaded to ensure extra parameters
        provided by 'postfix_relay_domains' are properly received.
        """
        super(ResourceTestCase, self).setUp()
        for tpl in LimitTemplates().templates:
            parameters.save_admin('DEFLT_%s' % tpl[0].upper(), 2, app='limits')
        populate_database()

 def test_autocreate_disabled(self):
     """Check if objects are not created as expected."""
     self.activate_ldap_authentication()
     self.searchbind_mode()
     parameters.save_admin("AUTO_CREATE_DOMAIN_AND_MAILBOX", "no")
     username = "[email protected]"
     self.authenticate(username, "test")
     self.assertFalse(
         models.Domain.objects.filter(name="example.com").exists())
     self.assertFalse(
         models.Mailbox.objects.filter(address="testuser").exists())

    def setUpTestData(cls):
        """Create test data."""
        super(LimitsTestCase, cls).setUpTestData()

        for tpl in LimitTemplates().templates:
            parameters.save_admin(
                "DEFLT_{0}".format(tpl[0].upper()), 2, app="limits"
            )
        cls.user = UserFactory.create(
            username='reseller', groups=('Resellers',)
        )

 def test_model(self):
     """Check few things about the model."""
     Radicale().load()
     mbox = Mailbox.objects.get(address="admin", domain__name="test.com")
     cal = UserCalendarFactory(name="MyCal", mailbox=mbox)
     with self.assertRaises(lib_exceptions.InternalError) as cm:
         url = cal.url
     self.assertEqual(
         str(cm.exception), "Server location is not set, please fix it.")
     parameters.save_admin(
         "SERVER_LOCATION", "http://localhost", app="modoboa_radicale")
     self.assertEqual(cal.url, "http://localhost/test.com/user/admin/MyCal")

    def setUp(self):
        """Custom setUp method.

        The 'limits' is manually loaded to ensure extra parameters
        provided by 'postfix_relay_domains' are properly received.
        """
        super(ResourceTestCase, self).setUp()
        #exts_pool.load_extension("modoboa_admin_limits")
        for tpl in LimitTemplates().templates:
            parameters.save_admin(
                "DEFLT_{0}".format(tpl[0].upper()), 2,
                app="modoboa_admin_limits"
            )
        populate_database()

    def setUp(self):
        super(LimitsTestCase, self).setUp()
        from modoboa_admin_limits.models import LimitTemplates

        for tpl in LimitTemplates().templates:
            parameters.save_admin(
                "DEFLT_{0}".format(tpl[0].upper()), 2,
                app="modoboa_admin_limits"
            )
        self.user = UserFactory.create(
            username='reseller', groups=('Resellers',)
        )
        self.clt.logout()
        self.clt.login(username='reseller', password='toto')

    def test_searchbind_authentication(self):
        """Test the bind&search method."""
        self.searchbind_mode()
        username = "[email protected]"
        self.authenticate(username, "test")
        self.check_created_user(username)
        self.client.logout()

        parameters.save_admin("LDAP_ADMIN_GROUPS", "admins")
        parameters.save_admin(
            "LDAP_GROUPS_SEARCH_BASE", "ou=groups,dc=example,dc=com")
        username = "[email protected]"
        self.authenticate(username, "test", False)
        self.check_created_user(username, "DomainAdmins")

 def test_create_using_default_quota(self):
     parameters.save_admin('DEFAULT_DOMAIN_QUOTA', 50, app='admin')
     values = {
         "name": "pouet.com", "create_dom_admin": "yes",
         "dom_admin_username": "toto", "create_aliases": "yes",
         "type": "domain", "stepid": 'step3'
     }
     self.ajax_post(
         reverse("admin:domain_add"),
         values
     )
     dom = Domain.objects.get(name="pouet.com")
     self.assertEqual(dom.quota, 50)
     da = User.objects.get(username="[email protected]")
     self.assertEqual(da.mailbox.quota, 50)

 def test_create_using_default_quota(self):
     parameters.save_admin('DEFAULT_DOMAIN_QUOTA', 50, app='admin')
     values = {
         "name": "pouet.com", "create_dom_admin": "yes",
         "dom_admin_username": "toto", "create_aliases": "yes",
         "stepid": 'step2'
     }
     self.ajax_post(
         reverse("modoboa.extensions.admin.views.domain.newdomain"),
         values
     )
     dom = Domain.objects.get(name="pouet.com")
     self.assertEqual(dom.quota, 50)
     da = User.objects.get(username="[email protected]")
     self.assertEqual(da.mailbox_set.all()[0].quota, 50)

 def test_domain_detail_view(self):
     """Test Domain detail view."""
     parameters.save_admin(
         "ENABLE_DOMAIN_LIMITS", "no", app="limits")
     domain = Domain.objects.get(name="test.com")
     url = reverse("admin:domain_detail", args=[domain.pk])
     response = self.client.get(url)
     self.assertEqual(response.status_code, 200)
     self.assertIn("Information", response.content)
     self.assertIn("Administrators", response.content)
     self.assertNotIn("Resources usage", response.content)
     parameters.save_admin(
         "ENABLE_DOMAIN_LIMITS", "yes", app="limits")
     response = self.client.get(url)
     self.assertIn("Resources usage", response.content)

    def setUpTestData(cls):
        """Create test data."""
        from modoboa.lib import parameters
        from modoboa.limits.models import LimitTemplates

        super(PermissionsTestCase, cls).setUpTestData()
        for tpl in LimitTemplates().templates:
            parameters.save_admin(
                "DEFLT_{0}".format(tpl[0].upper()), 2,
                app="limits"
            )
        factories.populate_database()
        cls.user = User.objects.get(username='[email protected]')
        cls.values = dict(
            username=cls.user.username, role="DomainAdmins",
            is_active=cls.user.is_active, email="[email protected]",
            quota_act=True
        )

    def setUpTestData(cls):
        """Create test data."""
        from modoboa.lib import parameters
        from modoboa.limits import utils as limits_utils

        super(PermissionsTestCase, cls).setUpTestData()
        for name, tpl in limits_utils.get_user_limit_templates():
            parameters.save_admin(
                "DEFLT_USER_{0}_LIMIT".format(name.upper()), 2,
                app="limits"
            )
        factories.populate_database()
        cls.user = User.objects.get(username='[email protected]')
        cls.values = dict(
            username=cls.user.username, role="DomainAdmins",
            is_active=cls.user.is_active, email="[email protected]",
            quota_act=True
        )

    def test_directbind_authentication(self):
        """Test the directbind method."""
        self.client.logout()
        self.directbind_mode()

        # 1: must fail because usernames of simple users must be email
        # addresses
        username = "testuser"
        with self.assertRaises(TypeError):
            self.client.login(username=username, password="test")

        # 1: must work because usernames of domain admins are not
        # always email addresses
        parameters.save_admin("LDAP_ADMIN_GROUPS", "admins")
        parameters.save_admin(
            "LDAP_GROUPS_SEARCH_BASE", "ou=groups,dc=example,dc=com")
        username = "mailadmin"
        self.authenticate(username, "test", False)
        self.check_created_user(username, "DomainAdmins", False)