def setUpTestData(cls):
super(ARMessageViewSetTestCase, cls).setUpTestData()
admin_factories.populate_database()
cls.account = User.objects.get(username="******")
cls.account2 = User.objects.get(username="******")
cls.arm = factories.ARmessageFactory(mbox=cls.account.mailbox)
cls.arm2 = factories.ARmessageFactory(mbox=cls.account2.mailbox)
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super().setUpTestData()
factories.populate_database()
factories.AlarmFactory(domain__name="test.com",
mailbox=None,
title="Test alarm")
def setUpTestData(cls):
"""Create test data."""
super(TestDataMixin, cls).setUpTestData()
admin_factories.populate_database()
cls.account = core_models.User.objects.get(username="******")
cls.calendar = factories.UserCalendarFactory(
mailbox=cls.account.mailbox)
cls.admin_account = core_models.User.objects.get(
username="******")
cls.calendar2 = factories.UserCalendarFactory(
mailbox=cls.admin_account.mailbox)
cls.acr1 = factories.AccessRuleFactory(
calendar=cls.calendar,
mailbox=cls.admin_account.mailbox,
read=True,
write=True)
cls.account2 = core_factories.UserFactory(
username="******",
groups=("SimpleUsers", ),
)
admin_factories.MailboxFactory.create(
address="user2",
domain=cls.account.mailbox.domain,
user=cls.account2)
cls.domain = admin_models.Domain.objects.get(name="test.com")
cls.scalendar = factories.SharedCalendarFactory(domain=cls.domain)
cls.domain2 = admin_models.Domain.objects.get(name="test2.com")
cls.scalendar2 = factories.SharedCalendarFactory(domain=cls.domain2)
def handle(self, *args, **options):
"""Command entry point."""
extensions.exts_pool.load_all()
if not models.User.objects.filter(is_superuser=True).count():
admin = models.User(username=options["admin_username"],
is_superuser=True)
admin.set_password("password")
admin.save()
models.ObjectAccess.objects.create(user=admin,
content_object=admin,
is_owner=True)
groups = list(constants.PERMISSIONS.keys())
for groupname in groups:
group, created = Group.objects.get_or_create(name=groupname)
results = signals.extra_role_permissions.send(
sender=self.__class__, role=groupname)
permissions = constants.PERMISSIONS.get(groupname, [])
if results:
permissions += reduce(lambda a, b: a + b,
[result[1] for result in results])
if not permissions:
continue
add_permissions_to_group(group, permissions)
for extname in list(extensions.exts_pool.extensions.keys()):
extension = extensions.exts_pool.get_extension(extname)
extension.load_initial_data()
signals.initial_data_loaded.send(sender=self.__class__,
extname=extname)
if options["extra_fixtures"]:
from modoboa.admin import factories
factories.populate_database()
def setUpTestData(cls):
super(DataMixin, cls).setUpTestData()
admin_factories.populate_database()
cls.mb = admin_models.Mailbox.objects.get(
user__username="******")
cls.migration = factories.MigrationFactory(
password="******", mailbox=cls.mb, username="******")
def handle(self, *args, **options):
"""Command entry point."""
extensions.exts_pool.load_all()
if not models.User.objects.filter(is_superuser=True).count():
admin = models.User(
username=options["admin_username"], is_superuser=True)
admin.set_password("password")
admin.save()
models.ObjectAccess.objects.create(
user=admin, content_object=admin, is_owner=True)
groups = list(constants.PERMISSIONS.keys())
for groupname in groups:
group, created = Group.objects.get_or_create(name=groupname)
results = signals.extra_role_permissions.send(
sender=self.__class__, role=groupname)
permissions = constants.PERMISSIONS.get(groupname, [])
if results:
permissions += reduce(
lambda a, b: a + b, [result[1] for result in results])
if not permissions:
continue
add_permissions_to_group(group, permissions)
for extname in list(extensions.exts_pool.extensions.keys()):
extension = extensions.exts_pool.get_extension(extname)
extension.load_initial_data()
signals.initial_data_loaded.send(
sender=self.__class__, extname=extname)
if options["extra_fixtures"]:
from modoboa.admin import factories
factories.populate_database()
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 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 setUpTestData(cls):
"""Create test data."""
super(LimitImportTestCase, cls).setUpTestData()
admin_factories.populate_database()
cls.reseller = core_factories.UserFactory(username="******",
groups=("Resellers", ))
cls.dadmin = core_models.User.objects.get(username="******")
cls.domain = admin_models.Domain.objects.get(name="test.com")
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):
"""Create test data."""
super(LimitImportTestCase, cls).setUpTestData()
admin_factories.populate_database()
cls.reseller = core_factories.UserFactory(
username="******", groups=("Resellers", ))
cls.dadmin = core_models.User.objects.get(username="******")
cls.domain = admin_models.Domain.objects.get(name="test.com")
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 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): # NOQA:N802
"""Create test data."""
super(AliasAPITestCase, cls).setUpTestData()
cls.localconfig.parameters.set_value(
"enable_admin_limits", False, app="limits")
cls.localconfig.save()
factories.populate_database()
cls.da_token = Token.objects.create(
user=core_models.User.objects.get(username="******"))
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(APIDomainLimitsTestCase, cls).setUpTestData()
cls.localconfig.parameters.set_value("enable_domain_limits", True)
for name, _definition in utils.get_domain_limit_templates():
cls.localconfig.parameters.set_value(
"deflt_domain_{0}_limit".format(name), 2)
cls.localconfig.save()
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 setUpTestData(cls): # NOQA:N802
"""Create test data."""
super().setUpTestData()
admin_factories.populate_database()
# FIXME: all database modifications must be made before the
# daemon is started otherwise they won't be seen by the other
# process. I think it's just a sqlite issue...
cls.admin = core_models.User.objects.get(username="******")
cls.admin.role = "SuperAdmins"
def setUpTestData(cls):
"""Custom setUpTestData method."""
super(ResourceTestCase, cls).setUpTestData()
parameters.save_admin("ENABLE_ADMIN_LIMITS", "yes")
parameters.save_admin("ENABLE_DOMAIN_LIMITS", "no")
for name, tpl in utils.get_user_limit_templates():
parameters.save_admin("DEFLT_USER_{0}_LIMIT".format(name.upper()),
2,
app="limits")
populate_database()
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(DomainAliasAPITestCase, cls).setUpTestData()
factories.populate_database()
cls.dom_alias1 = factories.DomainAliasFactory(name="dalias1.com",
target__name="test.com")
cls.dom_alias2 = factories.DomainAliasFactory(name="dalias2.com",
target__name="test2.com")
cls.da_token = Token.objects.create(user=core_models.User.objects.get(
username="******"))
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(APIDomainLimitsTestCase, cls).setUpTestData()
cls.localconfig.parameters.set_value(
"enable_domain_limits", True)
for name, _definition in utils.get_domain_limit_templates():
cls.localconfig.parameters.set_value(
"deflt_domain_{0}_limit".format(name), 2)
cls.localconfig.save()
populate_database()
def setUpTestData(cls):
"""Create test data."""
super(RelayDomainsTestCase, cls).setUpTestData()
admin_factories.populate_database()
cls.rdom = RelayDomainFactory(domain__name='relaydomain.tld')
admin_factories.DomainAliasFactory(name='relaydomainalias.tld',
target=cls.rdom.domain)
admin_factories.MailboxFactory(domain=cls.rdom.domain,
address="local",
user__username="******",
user__groups=("SimpleUsers", ))
def setUp(self):
super(RelayDomainsTestCase, self).setUp()
admin_factories.populate_database()
self.rdom = RelayDomainFactory(domain__name="relaydomain.tld")
admin_factories.DomainAliasFactory(name="relaydomainalias.tld", target=self.rdom.domain)
admin_factories.MailboxFactory(
domain=self.rdom.domain,
address="local",
user__username="******",
user__groups=("SimpleUsers",),
)
def setUpTestData(cls):
"""Custom setUpTestData method."""
super(ResourceTestCase, cls).setUpTestData()
cls.localconfig.parameters.set_values({
"enable_admin_limits": True,
"enable_domain_limits": False
})
for name, tpl in utils.get_user_limit_templates():
cls.localconfig.parameters.set_value(
"deflt_user_{0}_limit".format(name), 2)
cls.localconfig.save()
populate_database()
def setUpTestData(cls):
"""Custom setUpTestData method."""
super(ResourceTestCase, cls).setUpTestData()
cls.localconfig.parameters.set_values({
"enable_admin_limits": True,
"enable_domain_limits": False
})
for name, tpl in utils.get_user_limit_templates():
cls.localconfig.parameters.set_value(
"deflt_user_{0}_limit".format(name), 2)
cls.localconfig.save()
populate_database()
def setUpTestData(cls):
"""Create test data."""
super(DomainLimitsTestCase, cls).setUpTestData()
cls.localconfig.parameters.set_values({
"enable_admin_limits": False,
"enable_domain_limits": True
})
for name, tpl in utils.get_domain_limit_templates():
cls.localconfig.parameters.set_value(
"deflt_domain_{0}_limit".format(name), 2)
cls.localconfig.save()
admin_factories.populate_database()
def setUpTestData(cls):
"""Create test data."""
super(DomainLimitsTestCase, cls).setUpTestData()
cls.localconfig.parameters.set_values({
"enable_admin_limits": False,
"enable_domain_limits": True
})
for name, tpl in utils.get_domain_limit_templates():
cls.localconfig.parameters.set_value(
"deflt_domain_{0}_limit".format(name), 2)
cls.localconfig.save()
admin_factories.populate_database()
def setUpTestData(cls):
"""Create test data."""
super(RelayDomainsTestCase, cls).setUpTestData()
admin_factories.populate_database()
cls.rdom = RelayDomainFactory(domain__name='relaydomain.tld')
admin_factories.DomainAliasFactory(
name='relaydomainalias.tld', target=cls.rdom.domain)
admin_factories.MailboxFactory(
domain=cls.rdom.domain, address="local",
user__username="******",
user__groups=("SimpleUsers", )
)
def setUpTestData(cls):
"""Create test data."""
super(APIAdminLimitsTestCase, cls).setUpTestData()
for name, tpl in utils.get_user_limit_templates():
parameters.save_admin(
"DEFLT_USER_{}_LIMIT".format(name.upper()), 2)
populate_database()
cls.user = User.objects.get(username="******")
cls.da_token = Token.objects.create(user=cls.user)
cls.reseller = core_factories.UserFactory(
username="******", groups=("Resellers", ),
)
cls.r_token = Token.objects.create(user=cls.reseller)
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_{0}".format(tpl[0].upper()), 2,
app="limits"
)
populate_database()
def setUpTestData(cls):
"""Create test data."""
super(ResourcesAPITestCase, cls).setUpTestData()
for name, tpl in utils.get_user_limit_templates():
cls.localconfig.parameters.set_value(
"deflt_user_{0}_limit".format(name), 2)
cls.localconfig.save()
populate_database()
cls.user = User.objects.get(username="******")
cls.da_token = Token.objects.create(user=cls.user)
cls.reseller = core_factories.UserFactory(
username="******", groups=("Resellers", ),
)
cls.r_token = Token.objects.create(user=cls.reseller)
def setUp(self):
super().setUp()
call_command("load_initial_data")
admin_factories.populate_database()
self.admin = core_models.User.objects.get(username="******")
self.admin.role = "SuperAdmins"
patcher = patch("aiosmtplib.send")
self.send_mock = patcher.start()
self.process = Process(target=start_policy_daemon)
self.process.daemon = True
self.process.start()
# Wait a bit for the daemon to start
self.process.join(0.1)
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(ResourcesAPITestCase, cls).setUpTestData()
for name, _definition in utils.get_user_limit_templates():
cls.localconfig.parameters.set_value(
"deflt_user_{0}_limit".format(name), 2)
cls.localconfig.save()
populate_database()
cls.user = User.objects.get(username="******")
cls.da_token = Token.objects.create(user=cls.user)
cls.reseller = core_factories.UserFactory(
username="******", groups=("Resellers", ),
)
cls.r_token = Token.objects.create(user=cls.reseller)
def setUpTestData(cls):
"""Create test data."""
super(APIAdminLimitsTestCase, cls).setUpTestData()
for name, tpl in utils.get_user_limit_templates():
parameters.save_admin("DEFLT_USER_{}_LIMIT".format(name.upper()),
2)
populate_database()
cls.user = User.objects.get(username="******")
cls.da_token = Token.objects.create(user=cls.user)
cls.reseller = core_factories.UserFactory(
username="******",
groups=("Resellers", ),
)
cls.r_token = Token.objects.create(user=cls.reseller)
def setUpTestData(cls):
"""Create test data."""
super(RelayDomainsTestCase, cls).setUpTestData()
admin_factories.populate_database()
dom = admin_factories.DomainFactory(name="relaydomain.tld",
type="relaydomain")
dom.relaydomain.target_host = "external.host.tld"
dom.relaydomain.save()
cls.rdom = dom.relaydomain
admin_factories.DomainAliasFactory(name="relaydomainalias.tld",
target=cls.rdom.domain)
admin_factories.MailboxFactory(domain=cls.rdom.domain,
address="local",
user__username="******",
user__groups=("SimpleUsers", ))
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(SenderAddressAPITestCase, cls).setUpTestData()
cls.localconfig.parameters.set_value("enable_admin_limits",
False,
app="limits")
cls.localconfig.save()
factories.populate_database()
cls.sa1 = factories.SenderAddressFactory(
address="*****@*****.**",
mailbox__user__username="******",
mailbox__address="user",
mailbox__domain__name="test.com")
cls.da_token = Token.objects.create(user=core_models.User.objects.get(
username="******"))
def setUpTestData(cls):
"""Create test data."""
super(RelayDomainsTestCase, cls).setUpTestData()
admin_factories.populate_database()
dom = admin_factories.DomainFactory(
name="relaydomain.tld", type="relaydomain")
dom.relaydomain.target_host = "external.host.tld"
dom.relaydomain.save()
cls.rdom = dom.relaydomain
admin_factories.DomainAliasFactory(
name="relaydomainalias.tld", target=cls.rdom.domain)
admin_factories.MailboxFactory(
domain=cls.rdom.domain, address="local",
user__username="******",
user__groups=("SimpleUsers", )
)
def handle(self, *args, **options):
"""Command entry point."""
if not models.User.objects.filter(is_superuser=True).count():
admin = models.User(
username=options["admin_username"], is_superuser=True)
admin.set_password("password")
admin.save()
models.ObjectAccess.objects.create(
user=admin, content_object=admin, is_owner=True)
lc = models.LocalConfig.objects.first()
condition = (
"core" not in lc._parameters or
"secret_key" not in lc._parameters["core"])
if condition:
lc.parameters.set_value("secret_key", random_key())
lc.save()
for service_name in ["relay", "smtp"]:
relay_models.Service.objects.get_or_create(name=service_name)
extensions.exts_pool.load_all()
groups = list(constants.PERMISSIONS.keys())
for groupname in groups:
group, created = Group.objects.get_or_create(name=groupname)
results = signals.extra_role_permissions.send(
sender=self.__class__, role=groupname)
permissions = (
constants.PERMISSIONS.get(groupname, []) +
reduce(lambda a, b: a + b, [result[1] for result in results])
)
if not permissions:
continue
add_permissions_to_group(group, permissions)
for extname in list(extensions.exts_pool.extensions.keys()):
extension = extensions.exts_pool.get_extension(extname)
extension.load_initial_data()
signals.initial_data_loaded.send(
sender=self.__class__, extname=extname)
if options["extra_fixtures"]:
from modoboa.admin import factories
factories.populate_database()
def setUpTestData(cls):
"""Create test data."""
super(TestDataMixin, cls).setUpTestData()
admin_factories.populate_database()
cls.user = core_models.User.objects.get(username="******")
cls.category = factories.CategoryFactory(user=cls.user, name="Family")
cls.contact = factories.ContactFactory(
user=cls.user,
emails=["*****@*****.**"],
phone_numbers=["01234567889"],
)
factories.ContactFactory(user=cls.user,
first_name="Marge",
emails=["*****@*****.**"],
categories=[cls.category])
factories.ContactFactory(user=cls.user,
first_name="Bart",
emails=["*****@*****.**"])
def handle(self, *args, **options):
"""Command entry point."""
if not models.User.objects.filter(is_superuser=True).count():
admin = models.User(
username=options["admin_username"], is_superuser=True)
admin.set_password("password")
admin.save()
models.ObjectAccess.objects.create(
user=admin, content_object=admin, is_owner=True)
lc = models.LocalConfig.objects.first()
secret_key = lc.parameters.get_value("secret_key")
if not secret_key:
lc.parameters.set_value("secret_key", random_key())
lc.save()
for service_name in ["relay", "smtp"]:
relay_models.Service.objects.get_or_create(name=service_name)
exts_pool.load_all()
superadmin = models.User.objects.filter(is_superuser=True).first()
groups = PERMISSIONS.keys() + [
role[0] for role
in events.raiseQueryEvent("GetExtraRoles", superadmin, None)
]
for groupname in groups:
group, created = Group.objects.get_or_create(name=groupname)
permissions = (
PERMISSIONS.get(groupname, []) +
events.raiseQueryEvent("GetExtraRolePermissions", groupname)
)
if not permissions:
continue
add_permissions_to_group(group, permissions)
for extname in exts_pool.extensions.keys():
extension = exts_pool.get_extension(extname)
extension.load_initial_data()
events.raiseEvent("InitialDataLoaded", extname)
if options["extra_fixtures"]:
from modoboa.admin import factories
factories.populate_database()
def handle(self, *args, **options):
"""Command entry point."""
if not models.User.objects.filter(is_superuser=True).count():
admin = models.User(username=options["admin_username"],
is_superuser=True)
admin.set_password("password")
admin.save()
models.ObjectAccess.objects.create(user=admin,
content_object=admin,
is_owner=True)
lc = models.LocalConfig.objects.first()
secret_key = lc.parameters.get_value("secret_key")
if not secret_key:
lc.parameters.set_value("secret_key", random_key())
lc.save()
for service_name in ["relay", "smtp"]:
relay_models.Service.objects.get_or_create(name=service_name)
exts_pool.load_all()
superadmin = models.User.objects.filter(is_superuser=True).first()
groups = PERMISSIONS.keys() + [
role[0] for role in events.raiseQueryEvent("GetExtraRoles",
superadmin, None)
]
for groupname in groups:
group, created = Group.objects.get_or_create(name=groupname)
permissions = (
PERMISSIONS.get(groupname, []) +
events.raiseQueryEvent("GetExtraRolePermissions", groupname))
if not permissions:
continue
add_permissions_to_group(group, permissions)
for extname in exts_pool.extensions.keys():
extension = exts_pool.get_extension(extname)
extension.load_initial_data()
events.raiseEvent("InitialDataLoaded", extname)
if options["extra_fixtures"]:
from modoboa.admin import factories
factories.populate_database()
def setUpTestData(cls):
"""Create test data."""
super(RelayDomainsTestCase, cls).setUpTestData()
admin_factories.populate_database()
cls.dom = admin_factories.DomainFactory(name="relaydomain.tld",
type="relaydomain")
cls.transport = tr_factories.TransportFactory(
pattern=cls.dom.name,
_settings={
"relay_target_host": "external.host.tld",
"relay_target_port": "25",
"relay_verify_recipients": False
})
admin_factories.DomainAliasFactory(name="relaydomainalias.tld",
target=cls.dom)
admin_factories.MailboxFactory(domain=cls.dom,
address="local",
user__username="******",
user__groups=("SimpleUsers", ))
def handle(self, *args, **options):
"""Command entry point."""
if not User.objects.filter(is_superuser=True).count():
admin = User(username=options["admin_username"], is_superuser=True)
admin.set_password("password")
admin.save()
ObjectAccess.objects.create(user=admin,
content_object=admin,
is_owner=True)
param_name = "core.SECRET_KEY"
qset = lib_models.Parameter.objects.filter(name=param_name)
if not qset.exists():
lib_models.Parameter.objects.create(name=param_name,
value=random_key())
for service_name in ['relay', 'smtp']:
relay_models.Service.objects.get_or_create(name=service_name)
exts_pool.load_all()
superadmin = User.objects.filter(is_superuser=True).first()
groups = PERMISSIONS.keys() + [
role[0] for role in events.raiseQueryEvent("GetExtraRoles",
superadmin, None)
]
for groupname in groups:
group, created = Group.objects.get_or_create(name=groupname)
permissions = (
PERMISSIONS.get(groupname, []) +
events.raiseQueryEvent("GetExtraRolePermissions", groupname))
if not permissions:
continue
add_permissions_to_group(group, permissions)
for extname in exts_pool.extensions.keys():
extension = exts_pool.get_extension(extname)
extension.load_initial_data()
events.raiseEvent("InitialDataLoaded", extname)
if options['extra_fixtures']:
from modoboa.admin import factories
factories.populate_database()
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super().setUpTestData()
admin_factories.populate_database()
cls.spf_rec = factories.DNSRecordFactory(type="spf",
value="v=SPF1 mx -all",
is_valid=True,
domain__name="test.com")
cls.dmarc_rec = factories.DNSRecordFactory(type="dmarc",
value="XXX",
is_valid=False,
error="Not a DMARC record",
domain__name="test.com")
cls.dkim_rec = factories.DNSRecordFactory(type="dkim",
value="12345",
is_valid=False,
error="Public key mismatchs",
domain__name="test.com")
cls.ac_rec = factories.DNSRecordFactory(type="autoconfig",
value="1.2.3.4",
is_valid=True,
domain__name="test.com")
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(RelayDomainsTestCase, cls).setUpTestData()
admin_factories.populate_database()
cls.transport = tr_factories.TransportFactory(
pattern="relaydomain.tld", service="relay",
_settings={
"relay_target_host": "external.host.tld",
"relay_target_port": "25",
"relay_verify_recipients": False
}
)
cls.dom = admin_factories.DomainFactory(
name="relaydomain.tld", type="relaydomain",
transport=cls.transport)
admin_factories.DomainAliasFactory(
name="relaydomainalias.tld", target=cls.dom)
admin_factories.MailboxFactory(
domain=cls.dom, address="local",
user__username="******",
user__groups=("SimpleUsers", )
)
def setUpTestData(cls):
"""Create test data."""
super(EventsTestCase, cls).setUpTestData()
admin_factories.populate_database()
def setUpTestData(cls):
"""Create test data."""
super(PermissionsTestCase, cls).setUpTestData()
populate_database()
def setUpTestData(cls):
"""Create test data."""
super(AccessRuleTestCase, cls).setUpTestData()
populate_database()
def setUpTestData(cls):
"""Create some data."""
super(RepairTestCase, cls).setUpTestData()
admin_factories.populate_database()
def setUpTestData(cls):
"""Create test data."""
super(UserCalendarTestCase, cls).setUpTestData()
populate_database()
def setUpTestData(cls): # noqa
"""Create some users."""
super(WebmailTestCase, cls).setUpTestData()
admin_factories.populate_database()
cls.user = core_models.User.objects.get(username="******")
def setUp(self):
super(PermissionsTestCase, self).setUp()
populate_database()
def setUpTestData(cls): # NOQA:N802
"""Create test data."""
super(AccountAPITestCase, cls).setUpTestData()
factories.populate_database()
cls.da_token = Token.objects.create(user=core_models.User.objects.get(
username="******"))
def setUpTestData(cls):
"""Create some data."""
super(ManagementCommandTestCase, cls).setUpTestData()
admin_factories.populate_database()
cls.account = User.objects.get(username="******")
cls.arm = factories.ARmessageFactory(mbox=cls.account.mailbox)
def setUpTestData(cls):
"""Create test data."""
super(PermissionsTestCase, cls).setUpTestData()
populate_database()
