Fix tests for Python 3
- drop Python 2 __future__ imports - fix tests to handle new Django and Python 3 module names - reformat changed files with black
This commit is contained in:
parent
ddec6b4184
commit
3d18392b67
32 changed files with 2707 additions and 2675 deletions
|
|
@ -2,35 +2,33 @@
|
|||
This module provides tests for :py:mod:`userdbs.admin`.
|
||||
|
||||
"""
|
||||
from __future__ import absolute_import
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
|
||||
from django.contrib.admin import AdminSite
|
||||
from django.test import TestCase
|
||||
|
||||
from userdbs.admin import (DatabaseUserAdmin, DatabaseUserCreationForm,
|
||||
UserDatabaseAdmin, UserDatabaseCreationForm)
|
||||
from userdbs.admin import (
|
||||
DatabaseUserAdmin,
|
||||
DatabaseUserCreationForm,
|
||||
UserDatabaseAdmin,
|
||||
UserDatabaseCreationForm,
|
||||
)
|
||||
from userdbs.models import DB_TYPES, DatabaseUser, UserDatabase
|
||||
|
||||
try:
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
except ImportError:
|
||||
from mock import MagicMock, Mock, patch
|
||||
|
||||
|
||||
class DatabaseUserCreationFormTest(TestCase):
|
||||
|
||||
@patch('userdbs.admin.DatabaseUser.objects.create_database_user')
|
||||
@patch("userdbs.admin.DatabaseUser.objects.create_database_user")
|
||||
def test_save(self, create_database_user):
|
||||
create_database_user.return_value = Mock()
|
||||
form = DatabaseUserCreationForm()
|
||||
mockuser = Mock(name='osuser')
|
||||
form.cleaned_data = {
|
||||
'osuser': mockuser,
|
||||
'db_type': DB_TYPES.pgsql
|
||||
}
|
||||
mockuser = Mock(name="osuser")
|
||||
form.cleaned_data = {"osuser": mockuser, "db_type": DB_TYPES.pgsql}
|
||||
retval = form.save()
|
||||
self.assertTrue(create_database_user.called_with(
|
||||
osuser=mockuser, db_type=DB_TYPES.pgsql, commit=True))
|
||||
self.assertTrue(
|
||||
create_database_user.called_with(
|
||||
osuser=mockuser, db_type=DB_TYPES.pgsql, commit=True
|
||||
)
|
||||
)
|
||||
self.assertEqual(retval, create_database_user.return_value)
|
||||
|
||||
def test_save_m2m_returns_none(self):
|
||||
|
|
@ -39,16 +37,14 @@ class DatabaseUserCreationFormTest(TestCase):
|
|||
|
||||
|
||||
class UserDatabaseCreationFormTest(TestCase):
|
||||
|
||||
@patch('userdbs.admin.UserDatabase.objects.create_userdatabase')
|
||||
@patch("userdbs.admin.UserDatabase.objects.create_userdatabase")
|
||||
def test_save(self, create_userdatabase):
|
||||
create_userdatabase.return_value = Mock()
|
||||
form = UserDatabaseCreationForm()
|
||||
mockuser = Mock(name='mockuser')
|
||||
form.cleaned_data = {'db_user': mockuser}
|
||||
mockuser = Mock(name="mockuser")
|
||||
form.cleaned_data = {"db_user": mockuser}
|
||||
retval = form.save()
|
||||
self.assertTrue(create_userdatabase.called_with(
|
||||
db_user=mockuser, commit=True))
|
||||
self.assertTrue(create_userdatabase.called_with(db_user=mockuser, commit=True))
|
||||
self.assertEqual(retval, create_userdatabase.return_value)
|
||||
|
||||
def test_save_m2m_returns_none(self):
|
||||
|
|
@ -57,116 +53,96 @@ class UserDatabaseCreationFormTest(TestCase):
|
|||
|
||||
|
||||
class DatabaseUserAdminTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
site = AdminSite()
|
||||
self.dbuadmin = DatabaseUserAdmin(DatabaseUser, site)
|
||||
super(DatabaseUserAdminTest, self).setUp()
|
||||
|
||||
def test_get_form_with_instance(self):
|
||||
form = self.dbuadmin.get_form(
|
||||
Mock(name='request'), obj=Mock(name='dbuser'))
|
||||
self.assertEqual(
|
||||
form.Meta.fields,
|
||||
['osuser', 'name', 'db_type']
|
||||
)
|
||||
form = self.dbuadmin.get_form(Mock(name="request"), obj=Mock(name="dbuser"))
|
||||
self.assertEqual(form.Meta.fields, ["osuser", "name", "db_type"])
|
||||
|
||||
def test_get_form_without_instance(self):
|
||||
form = self.dbuadmin.get_form(Mock(name='request'))
|
||||
self.assertEqual(
|
||||
form.Meta.fields,
|
||||
['osuser', 'db_type']
|
||||
)
|
||||
form = self.dbuadmin.get_form(Mock(name="request"))
|
||||
self.assertEqual(form.Meta.fields, ["osuser", "db_type"])
|
||||
|
||||
def test_get_readonly_fields_with_instance(self):
|
||||
fields = self.dbuadmin.get_readonly_fields(
|
||||
Mock(name='request'), obj=Mock(name='dbuser'))
|
||||
self.assertEqual(
|
||||
fields, ['osuser', 'name', 'db_type'])
|
||||
Mock(name="request"), obj=Mock(name="dbuser")
|
||||
)
|
||||
self.assertEqual(fields, ["osuser", "name", "db_type"])
|
||||
|
||||
def test_get_readonly_fields_without_instance(self):
|
||||
fields = self.dbuadmin.get_readonly_fields(
|
||||
Mock(name='request'))
|
||||
fields = self.dbuadmin.get_readonly_fields(Mock(name="request"))
|
||||
self.assertEqual(fields, [])
|
||||
|
||||
def test_save_model_change(self):
|
||||
objmock = Mock()
|
||||
self.dbuadmin.save_model(Mock(name='request'), objmock, Mock(), True)
|
||||
self.dbuadmin.save_model(Mock(name="request"), objmock, Mock(), True)
|
||||
self.assertTrue(objmock.create_in_database.not_called())
|
||||
|
||||
def test_save_model_no_change(self):
|
||||
objmock = Mock()
|
||||
self.dbuadmin.save_model(Mock(name='request'), objmock, Mock(), False)
|
||||
self.dbuadmin.save_model(Mock(name="request"), objmock, Mock(), False)
|
||||
self.assertTrue(objmock.create_in_database.called_with())
|
||||
|
||||
def test_perform_delete_selected(self):
|
||||
usermock = Mock()
|
||||
selected = Mock()
|
||||
selected.all.return_value = [usermock]
|
||||
self.dbuadmin.perform_delete_selected(Mock(name='request'), selected)
|
||||
self.dbuadmin.perform_delete_selected(Mock(name="request"), selected)
|
||||
self.assertTrue(selected.all.called_with())
|
||||
self.assertTrue(usermock.delete.called_with())
|
||||
|
||||
def test_get_actions(self):
|
||||
requestmock = MagicMock(name='request')
|
||||
self.assertNotIn(
|
||||
'delete_selected',
|
||||
self.dbuadmin.get_actions(requestmock))
|
||||
self.assertIn(
|
||||
'perform_delete_selected',
|
||||
self.dbuadmin.get_actions(requestmock))
|
||||
requestmock = MagicMock(name="request")
|
||||
self.assertNotIn("delete_selected", self.dbuadmin.get_actions(requestmock))
|
||||
self.assertIn("perform_delete_selected", self.dbuadmin.get_actions(requestmock))
|
||||
|
||||
|
||||
class UserDatabaseAdminTest(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
site = AdminSite()
|
||||
self.udbadmin = UserDatabaseAdmin(UserDatabase, site)
|
||||
super(UserDatabaseAdminTest, self).setUp()
|
||||
|
||||
def test_get_form_with_instance(self):
|
||||
form = self.udbadmin.get_form(
|
||||
Mock(name='request'), obj=Mock(name='userdb'))
|
||||
self.assertEqual(form.Meta.fields, ['db_name', 'db_user'])
|
||||
form = self.udbadmin.get_form(Mock(name="request"), obj=Mock(name="userdb"))
|
||||
self.assertEqual(form.Meta.fields, ["db_name", "db_user"])
|
||||
|
||||
def test_get_form_without_instance(self):
|
||||
form = self.udbadmin.get_form(Mock(name='request'))
|
||||
self.assertEqual(form.Meta.fields, ['db_user'])
|
||||
form = self.udbadmin.get_form(Mock(name="request"))
|
||||
self.assertEqual(form.Meta.fields, ["db_user"])
|
||||
|
||||
def test_get_readonly_fields_with_instance(self):
|
||||
fields = self.udbadmin.get_readonly_fields(
|
||||
Mock(name='request'), obj=Mock(name='userdb'))
|
||||
self.assertEqual(
|
||||
fields, ['db_name', 'db_user'])
|
||||
Mock(name="request"), obj=Mock(name="userdb")
|
||||
)
|
||||
self.assertEqual(fields, ["db_name", "db_user"])
|
||||
|
||||
def test_get_readonly_fields_without_instance(self):
|
||||
fields = self.udbadmin.get_readonly_fields(
|
||||
Mock(name='request'))
|
||||
fields = self.udbadmin.get_readonly_fields(Mock(name="request"))
|
||||
self.assertEqual(fields, [])
|
||||
|
||||
def test_save_model_change(self):
|
||||
objmock = Mock()
|
||||
self.udbadmin.save_model(Mock(name='request'), objmock, Mock(), True)
|
||||
self.udbadmin.save_model(Mock(name="request"), objmock, Mock(), True)
|
||||
self.assertTrue(objmock.create_in_database.not_called())
|
||||
|
||||
def test_save_model_no_change(self):
|
||||
objmock = Mock()
|
||||
self.udbadmin.save_model(Mock(name='request'), objmock, Mock(), False)
|
||||
self.udbadmin.save_model(Mock(name="request"), objmock, Mock(), False)
|
||||
self.assertTrue(objmock.create_in_database.called_with())
|
||||
|
||||
def test_perform_delete_selected(self):
|
||||
userdbmock = Mock()
|
||||
selected = Mock()
|
||||
selected.all.return_value = [userdbmock]
|
||||
self.udbadmin.perform_delete_selected(Mock(name='request'), selected)
|
||||
self.udbadmin.perform_delete_selected(Mock(name="request"), selected)
|
||||
self.assertTrue(selected.all.called_with())
|
||||
self.assertTrue(userdbmock.delete.called_with())
|
||||
|
||||
def test_get_actions(self):
|
||||
requestmock = MagicMock(name='request')
|
||||
self.assertNotIn(
|
||||
'delete_selected',
|
||||
self.udbadmin.get_actions(requestmock))
|
||||
self.assertIn(
|
||||
'perform_delete_selected',
|
||||
self.udbadmin.get_actions(requestmock))
|
||||
requestmock = MagicMock(name="request")
|
||||
self.assertNotIn("delete_selected", self.udbadmin.get_actions(requestmock))
|
||||
self.assertIn("perform_delete_selected", self.udbadmin.get_actions(requestmock))
|
||||
|
|
|
|||
|
|
@ -2,20 +2,15 @@
|
|||
This module provides tests for :py:mod:`userdbs.forms`.
|
||||
|
||||
"""
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django import forms
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
from django.urls import reverse
|
||||
|
||||
from userdbs.forms import AddUserDatabaseForm, ChangeDatabaseUserPasswordForm
|
||||
from userdbs.models import DB_TYPES
|
||||
|
||||
try:
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
except ImportError:
|
||||
from mock import MagicMock, Mock, patch
|
||||
from unittest.mock import MagicMock, Mock, patch
|
||||
|
||||
|
||||
Customer = get_user_model()
|
||||
|
|
@ -33,66 +28,68 @@ class AddUserDatabaseFormTest(TestCase):
|
|||
def test_constructor_needs_hostingpackage(self):
|
||||
with self.assertRaises(KeyError) as ke:
|
||||
AddUserDatabaseForm(instance=Mock())
|
||||
self.assertEqual(ke.exception.args[0], 'hostingpackage')
|
||||
self.assertEqual(ke.exception.args[0], "hostingpackage")
|
||||
|
||||
def test_constructor_needs_dbtypes(self):
|
||||
with self.assertRaises(KeyError) as ke:
|
||||
AddUserDatabaseForm(instance=Mock(), hostingpackage=Mock())
|
||||
self.assertEqual(ke.exception.args[0], 'dbtypes')
|
||||
self.assertEqual(ke.exception.args[0], "dbtypes")
|
||||
|
||||
def test_constructor_one_dbtype(self):
|
||||
self._setup_hostingpackage()
|
||||
dbtypes = [(DB_TYPES.pgsql, DB_TYPES[DB_TYPES.pgsql])]
|
||||
form = AddUserDatabaseForm(
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage,
|
||||
dbtypes=dbtypes)
|
||||
self.assertIn('db_type', form.fields)
|
||||
self.assertEqual(form.fields['db_type'].choices, dbtypes)
|
||||
self.assertTrue(isinstance(
|
||||
form.fields['db_type'].widget,
|
||||
forms.HiddenInput))
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'add_userdatabase', kwargs={'package': self.hostingpackage.id}))
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage, dbtypes=dbtypes
|
||||
)
|
||||
self.assertIn("db_type", form.fields)
|
||||
self.assertEqual(form.fields["db_type"].choices, dbtypes)
|
||||
self.assertTrue(isinstance(form.fields["db_type"].widget, forms.HiddenInput))
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("add_userdatabase", kwargs={"package": self.hostingpackage.id}),
|
||||
)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
|
||||
def test_constructor_multiple_dbtypes(self):
|
||||
self._setup_hostingpackage()
|
||||
dbtypes = [
|
||||
(DB_TYPES.pgsql, DB_TYPES[DB_TYPES.pgsql]),
|
||||
(DB_TYPES.mysql, DB_TYPES[DB_TYPES.mysql])
|
||||
(DB_TYPES.mysql, DB_TYPES[DB_TYPES.mysql]),
|
||||
]
|
||||
form = AddUserDatabaseForm(
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage,
|
||||
dbtypes=dbtypes)
|
||||
self.assertIn('db_type', form.fields)
|
||||
self.assertEqual(form.fields['db_type'].choices, dbtypes)
|
||||
self.assertTrue(isinstance(
|
||||
form.fields['db_type'].widget,
|
||||
forms.RadioSelect))
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'add_userdatabase', kwargs={'package': self.hostingpackage.id}))
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage, dbtypes=dbtypes
|
||||
)
|
||||
self.assertIn("db_type", form.fields)
|
||||
self.assertEqual(form.fields["db_type"].choices, dbtypes)
|
||||
self.assertTrue(isinstance(form.fields["db_type"].widget, forms.RadioSelect))
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("add_userdatabase", kwargs={"package": self.hostingpackage.id}),
|
||||
)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
|
||||
@patch('userdbs.forms.UserDatabase.objects.create_userdatabase_with_user')
|
||||
@patch("userdbs.forms.UserDatabase.objects.create_userdatabase_with_user")
|
||||
def test_save(self, create_userdatabase_with_user):
|
||||
self._setup_hostingpackage()
|
||||
dbtypes = [
|
||||
(DB_TYPES.pgsql, DB_TYPES[DB_TYPES.pgsql]),
|
||||
(DB_TYPES.mysql, DB_TYPES[DB_TYPES.mysql])
|
||||
(DB_TYPES.mysql, DB_TYPES[DB_TYPES.mysql]),
|
||||
]
|
||||
form = AddUserDatabaseForm(
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage,
|
||||
dbtypes=dbtypes)
|
||||
form.cleaned_data = {
|
||||
'db_type': DB_TYPES.pgsql,
|
||||
'password1': 'secret',
|
||||
}
|
||||
instance=MagicMock(), hostingpackage=self.hostingpackage, dbtypes=dbtypes
|
||||
)
|
||||
form.cleaned_data = {"db_type": DB_TYPES.pgsql, "password1": "secret"}
|
||||
form.save()
|
||||
self.assertTrue(create_userdatabase_with_user.called_with(
|
||||
DB_TYPES.pgsql, self.hostingpackage.osuser,
|
||||
password='secret', commit=True))
|
||||
self.assertTrue(
|
||||
create_userdatabase_with_user.called_with(
|
||||
DB_TYPES.pgsql,
|
||||
self.hostingpackage.osuser,
|
||||
password="secret",
|
||||
commit=True,
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class ChangeDatabaseUserPasswordFormTest(TestCase):
|
||||
|
|
@ -107,29 +104,31 @@ class ChangeDatabaseUserPasswordFormTest(TestCase):
|
|||
def test_constructor_needs_hostingpackage(self):
|
||||
with self.assertRaises(KeyError) as ke:
|
||||
ChangeDatabaseUserPasswordForm(instance=Mock())
|
||||
self.assertEqual(ke.exception.args[0], 'hostingpackage')
|
||||
self.assertEqual(ke.exception.args[0], "hostingpackage")
|
||||
|
||||
def test_constructor(self):
|
||||
self._setup_hostingpackage()
|
||||
instance = MagicMock()
|
||||
instance.name = 'test'
|
||||
instance.name = "test"
|
||||
form = ChangeDatabaseUserPasswordForm(
|
||||
instance=instance, hostingpackage=self.hostingpackage)
|
||||
self.assertIn('password1', form.fields)
|
||||
self.assertIn('password2', form.fields)
|
||||
self.assertTrue(hasattr(form, 'helper'))
|
||||
self.assertEqual(form.helper.form_action, reverse(
|
||||
'change_dbuser_password', kwargs={
|
||||
'slug': 'test', 'package': 42
|
||||
}))
|
||||
self.assertEqual(form.helper.inputs[0].name, 'submit')
|
||||
instance=instance, hostingpackage=self.hostingpackage
|
||||
)
|
||||
self.assertIn("password1", form.fields)
|
||||
self.assertIn("password2", form.fields)
|
||||
self.assertTrue(hasattr(form, "helper"))
|
||||
self.assertEqual(
|
||||
form.helper.form_action,
|
||||
reverse("change_dbuser_password", kwargs={"slug": "test", "package": 42}),
|
||||
)
|
||||
self.assertEqual(form.helper.inputs[0].name, "submit")
|
||||
|
||||
def test_save(self):
|
||||
instance = MagicMock()
|
||||
instance.name = 'test'
|
||||
instance.name = "test"
|
||||
self._setup_hostingpackage()
|
||||
form = ChangeDatabaseUserPasswordForm(
|
||||
instance=instance, hostingpackage=self.hostingpackage)
|
||||
form.cleaned_data = {'password1': 'secret'}
|
||||
instance=instance, hostingpackage=self.hostingpackage
|
||||
)
|
||||
form.cleaned_data = {"password1": "secret"}
|
||||
form.save()
|
||||
self.assertTrue(instance.set_password.called_with('secret'))
|
||||
self.assertTrue(instance.set_password.called_with("secret"))
|
||||
|
|
|
|||
|
|
@ -2,8 +2,6 @@
|
|||
This module provides tests for :py:mod:`userdbs.models`.
|
||||
|
||||
"""
|
||||
from __future__ import unicode_literals
|
||||
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.test import TestCase
|
||||
from django.test.utils import override_settings
|
||||
|
|
@ -16,9 +14,7 @@ Customer = get_user_model()
|
|||
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
)
|
||||
class TestCaseWithCeleryTasks(TestCase):
|
||||
pass
|
||||
|
|
@ -29,93 +25,85 @@ class DatabaseUserManagerTest(TestCaseWithCeleryTasks):
|
|||
Test case for :py:class:`userdbs.models.DatabaseUserManager`.
|
||||
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create_user(username='testcustomer')
|
||||
self.customer = Customer.objects.create_user(username="testcustomer")
|
||||
self.osuser = User.objects.create_user(customer=self.customer)
|
||||
TaskResult.objects.all().delete()
|
||||
|
||||
def test_create_database_user_with_name(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.pgsql, 'testname', 'secret')
|
||||
self.assertEqual(dbu.name, 'testname')
|
||||
self.osuser, DB_TYPES.pgsql, "testname", "secret"
|
||||
)
|
||||
self.assertEqual(dbu.name, "testname")
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.pgsql)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql user creation')
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "pgsql user creation")
|
||||
|
||||
def test_create_database_user_with_name_no_commit(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.pgsql, 'testname', 'secret', False)
|
||||
self.assertEqual(dbu.name, 'testname')
|
||||
self.osuser, DB_TYPES.pgsql, "testname", "secret", False
|
||||
)
|
||||
self.assertEqual(dbu.name, "testname")
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.pgsql)
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_create_database_user_generate_name(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.pgsql)
|
||||
self.assertEqual(dbu.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.pgsql)
|
||||
self.assertEqual(dbu.name, "{user}db01".format(user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.pgsql)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql user creation')
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "pgsql user creation")
|
||||
|
||||
def test_create_database_user_multiple_generate_name(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db01".format(user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db02'.format(
|
||||
user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db02".format(user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 2)
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[1].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[1].notes, "mysql user creation")
|
||||
|
||||
def test_create_database_user_multiple_gap_generate_name(self):
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db01".format(user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db02'.format(
|
||||
user=self.osuser.username))
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db02".format(user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
DatabaseUser.objects.get(
|
||||
name='{user}db01'.format(user=self.osuser.username)).delete()
|
||||
dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
name="{user}db01".format(user=self.osuser.username)
|
||||
).delete()
|
||||
dbu = DatabaseUser.objects.create_database_user(self.osuser, DB_TYPES.mysql)
|
||||
self.assertEqual(dbu.name, "{user}db01".format(user=self.osuser.username))
|
||||
self.assertEqual(dbu.osuser, self.osuser)
|
||||
self.assertEqual(dbu.db_type, DB_TYPES.mysql)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 4)
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[1].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[2].creator, 'handle_dbuser_deleted')
|
||||
self.assertEqual(taskres[2].notes, 'mysql user deletion')
|
||||
self.assertEqual(taskres[3].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[3].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[1].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[2].creator, "handle_dbuser_deleted")
|
||||
self.assertEqual(taskres[2].notes, "mysql user deletion")
|
||||
self.assertEqual(taskres[3].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[3].notes, "mysql user creation")
|
||||
|
||||
|
||||
class DatabaseUserTest(TestCaseWithCeleryTasks):
|
||||
|
|
@ -123,41 +111,43 @@ class DatabaseUserTest(TestCaseWithCeleryTasks):
|
|||
Test case for :py:class:`userdbs.models.DatabaseUser`.
|
||||
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create_user(username='testcustomer')
|
||||
self.customer = Customer.objects.create_user(username="testcustomer")
|
||||
self.osuser = User.objects.create_user(customer=self.customer)
|
||||
self.dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, DB_TYPES.pgsql)
|
||||
self.osuser, DB_TYPES.pgsql
|
||||
)
|
||||
TaskResult.objects.all().delete()
|
||||
|
||||
def test___str__(self):
|
||||
self.assertEqual(
|
||||
str(self.dbu),
|
||||
'{user}db01 (PostgreSQL for {user})'.format(
|
||||
user=self.osuser.username))
|
||||
"{user}db01 (PostgreSQL for {user})".format(user=self.osuser.username),
|
||||
)
|
||||
|
||||
def test_set_password_pgsql(self):
|
||||
self.dbu.set_password('secret')
|
||||
self.dbu.set_password("secret")
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_password_set')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql password change')
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_password_set")
|
||||
self.assertEqual(taskres[0].notes, "pgsql password change")
|
||||
|
||||
def test_set_password_mysql(self):
|
||||
self.dbu.db_type = DB_TYPES.mysql
|
||||
self.dbu.save()
|
||||
self.dbu.set_password('secret')
|
||||
self.dbu.set_password("secret")
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_password_set')
|
||||
self.assertEqual(taskres[0].notes, 'mysql password change')
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_password_set")
|
||||
self.assertEqual(taskres[0].notes, "mysql password change")
|
||||
|
||||
def test_delete_no_dbs(self):
|
||||
self.dbu.delete()
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_deleted')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql user deletion')
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_deleted")
|
||||
self.assertEqual(taskres[0].notes, "pgsql user deletion")
|
||||
|
||||
def test_delete_with_dbs(self):
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
|
|
@ -166,12 +156,12 @@ class DatabaseUserTest(TestCaseWithCeleryTasks):
|
|||
self.assertFalse(UserDatabase.objects.filter(id=dbid).exists())
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 3)
|
||||
self.assertEqual(taskres[0].creator, 'handle_userdb_created')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql database creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_userdb_deleted')
|
||||
self.assertEqual(taskres[1].notes, 'pgsql database deletion')
|
||||
self.assertEqual(taskres[2].creator, 'handle_dbuser_deleted')
|
||||
self.assertEqual(taskres[2].notes, 'pgsql user deletion')
|
||||
self.assertEqual(taskres[0].creator, "handle_userdb_created")
|
||||
self.assertEqual(taskres[0].notes, "pgsql database creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_userdb_deleted")
|
||||
self.assertEqual(taskres[1].notes, "pgsql database deletion")
|
||||
self.assertEqual(taskres[2].creator, "handle_dbuser_deleted")
|
||||
self.assertEqual(taskres[2].notes, "pgsql user deletion")
|
||||
|
||||
|
||||
class UserDatabaseManagerTest(TestCaseWithCeleryTasks):
|
||||
|
|
@ -179,50 +169,52 @@ class UserDatabaseManagerTest(TestCaseWithCeleryTasks):
|
|||
Test case for :py:class:`userdbs.models.UserDatabaseManager`.
|
||||
|
||||
"""
|
||||
|
||||
def setUp(self):
|
||||
self.customer = Customer.objects.create_user(username='testcustomer')
|
||||
self.customer = Customer.objects.create_user(username="testcustomer")
|
||||
self.osuser = User.objects.create_user(customer=self.customer)
|
||||
TaskResult.objects.all().delete()
|
||||
|
||||
def _create_database_user(self, dbtype):
|
||||
self.dbu = DatabaseUser.objects.create_database_user(
|
||||
self.osuser, dbtype)
|
||||
self.dbu = DatabaseUser.objects.create_database_user(self.osuser, dbtype)
|
||||
TaskResult.objects.all().delete()
|
||||
|
||||
def test_create_userdatabase_with_user_mysql(self):
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(
|
||||
DB_TYPES.mysql, self.osuser)
|
||||
self.assertEqual(db.db_name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(db.db_user.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
DB_TYPES.mysql, self.osuser
|
||||
)
|
||||
self.assertEqual(db.db_name, "{user}db01".format(user=self.osuser.username))
|
||||
self.assertEqual(
|
||||
db.db_user.name, "{user}db01".format(user=self.osuser.username)
|
||||
)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 2)
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'mysql user creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_userdb_created')
|
||||
self.assertEqual(taskres[1].notes, 'mysql database creation')
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "mysql user creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_userdb_created")
|
||||
self.assertEqual(taskres[1].notes, "mysql database creation")
|
||||
|
||||
def test_create_userdatabase_with_user_pgsql(self):
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(
|
||||
DB_TYPES.pgsql, self.osuser)
|
||||
self.assertEqual(db.db_name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
self.assertEqual(db.db_user.name, '{user}db01'.format(
|
||||
user=self.osuser.username))
|
||||
DB_TYPES.pgsql, self.osuser
|
||||
)
|
||||
self.assertEqual(db.db_name, "{user}db01".format(user=self.osuser.username))
|
||||
self.assertEqual(
|
||||
db.db_user.name, "{user}db01".format(user=self.osuser.username)
|
||||
)
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 2)
|
||||
self.assertEqual(taskres[0].creator, 'handle_dbuser_created')
|
||||
self.assertEqual(taskres[0].notes, 'pgsql user creation')
|
||||
self.assertEqual(taskres[1].creator, 'handle_userdb_created')
|
||||
self.assertEqual(taskres[1].notes, 'pgsql database creation')
|
||||
self.assertEqual(taskres[0].creator, "handle_dbuser_created")
|
||||
self.assertEqual(taskres[0].notes, "pgsql user creation")
|
||||
self.assertEqual(taskres[1].creator, "handle_userdb_created")
|
||||
self.assertEqual(taskres[1].notes, "pgsql database creation")
|
||||
|
||||
def test_create_userdatabase_given_name_no_new_write(self):
|
||||
self._create_database_user(DB_TYPES.pgsql)
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu, db_name='test')
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu, db_name="test")
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(db.db_name, 'test')
|
||||
self.assertEqual(db.db_name, "test")
|
||||
TaskResult.objects.all().delete()
|
||||
db.save()
|
||||
taskres = TaskResult.objects.all()
|
||||
|
|
@ -230,11 +222,11 @@ class UserDatabaseManagerTest(TestCaseWithCeleryTasks):
|
|||
|
||||
def test_create_userdatabase_given_name(self):
|
||||
self._create_database_user(DB_TYPES.pgsql)
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu, db_name='test')
|
||||
self.assertEqual(db.db_name, 'test')
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu, db_name="test")
|
||||
self.assertEqual(db.db_name, "test")
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 1)
|
||||
self.assertEqual(db.db_name, 'test')
|
||||
self.assertEqual(db.db_name, "test")
|
||||
|
||||
def test_create_userdatabase_generate_name_no_commit(self):
|
||||
self._create_database_user(DB_TYPES.pgsql)
|
||||
|
|
@ -252,19 +244,19 @@ class UserDatabaseManagerTest(TestCaseWithCeleryTasks):
|
|||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, self.dbu.name)
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, '{user}_02'.format(user=self.dbu.name))
|
||||
self.assertEqual(db.db_name, "{user}_02".format(user=self.dbu.name))
|
||||
|
||||
def test_create_userdatabase_multiple_gap_generate_name(self):
|
||||
self._create_database_user(DB_TYPES.pgsql)
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, self.dbu.name)
|
||||
dbx = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(dbx.db_name, '{user}_02'.format(user=self.dbu.name))
|
||||
self.assertEqual(dbx.db_name, "{user}_02".format(user=self.dbu.name))
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, '{user}_03'.format(user=self.dbu.name))
|
||||
self.assertEqual(db.db_name, "{user}_03".format(user=self.dbu.name))
|
||||
dbx.delete()
|
||||
db = UserDatabase.objects.create_userdatabase(self.dbu)
|
||||
self.assertEqual(db.db_name, '{user}_02'.format(user=self.dbu.name))
|
||||
self.assertEqual(db.db_name, "{user}_02".format(user=self.dbu.name))
|
||||
|
||||
|
||||
class UserDatabaseTest(TestCaseWithCeleryTasks):
|
||||
|
|
@ -272,24 +264,23 @@ class UserDatabaseTest(TestCaseWithCeleryTasks):
|
|||
Test case for :py:class:`userdbs.models.UserDabase`.
|
||||
|
||||
"""
|
||||
|
||||
def test___str__(self):
|
||||
customer = Customer.objects.create_user(username='testcustomer')
|
||||
customer = Customer.objects.create_user(username="testcustomer")
|
||||
osuser = User.objects.create_user(customer=customer)
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(
|
||||
DB_TYPES.pgsql, osuser)
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(DB_TYPES.pgsql, osuser)
|
||||
self.assertEqual(
|
||||
str(db),
|
||||
'{user}db01 ({dbuser})'.format(
|
||||
user=osuser.username, dbuser=db.db_user))
|
||||
"{user}db01 ({dbuser})".format(user=osuser.username, dbuser=db.db_user),
|
||||
)
|
||||
|
||||
def test_delete_mysql_db(self):
|
||||
customer = Customer.objects.create_user(username='testcustomer')
|
||||
customer = Customer.objects.create_user(username="testcustomer")
|
||||
osuser = User.objects.create_user(customer=customer)
|
||||
TaskResult.objects.all().delete()
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(
|
||||
DB_TYPES.mysql, osuser)
|
||||
db = UserDatabase.objects.create_userdatabase_with_user(DB_TYPES.mysql, osuser)
|
||||
db.delete()
|
||||
taskres = TaskResult.objects.all()
|
||||
self.assertEqual(len(taskres), 3)
|
||||
self.assertEqual(taskres[2].creator, 'handle_userdb_deleted')
|
||||
self.assertEqual(taskres[2].notes, 'mysql database deletion')
|
||||
self.assertEqual(taskres[2].creator, "handle_userdb_deleted")
|
||||
self.assertEqual(taskres[2].notes, "mysql database deletion")
|
||||
|
|
|
|||
|
|
@ -4,63 +4,60 @@ This module contains explicit tests for corner cases in
|
|||
:py:mod:`userdbs.tests.test_models`.
|
||||
|
||||
"""
|
||||
from __future__ import unicode_literals
|
||||
from unittest.mock import Mock
|
||||
|
||||
from django.test import TestCase
|
||||
from django.test.utils import override_settings
|
||||
|
||||
from taskresults.models import TaskResult
|
||||
from userdbs.signals import (handle_dbuser_created, handle_dbuser_deleted,
|
||||
handle_dbuser_password_set, handle_userdb_created,
|
||||
handle_userdb_deleted)
|
||||
|
||||
try:
|
||||
from unittest.mock import Mock
|
||||
except ImportError:
|
||||
from mock import Mock
|
||||
from userdbs.signals import (
|
||||
handle_dbuser_created,
|
||||
handle_dbuser_deleted,
|
||||
handle_dbuser_password_set,
|
||||
handle_userdb_created,
|
||||
handle_userdb_deleted,
|
||||
)
|
||||
|
||||
|
||||
@override_settings(
|
||||
CELERY_ALWAYS_EAGER=True,
|
||||
CELERY_CACHE_BACKEND='memory',
|
||||
BROKER_BACKEND='memory'
|
||||
CELERY_ALWAYS_EAGER=True, CELERY_CACHE_BACKEND="memory", BROKER_BACKEND="memory"
|
||||
)
|
||||
class TestCaseWithCeleryTasks(TestCase):
|
||||
pass
|
||||
|
||||
|
||||
class TestWithUnknownDBType(TestCaseWithCeleryTasks):
|
||||
|
||||
def test_handle_dbuser_password_set_unknown(self):
|
||||
instance = Mock(data={'name': 'test', 'db_type': -1})
|
||||
handle_dbuser_password_set(Mock(name='sender'), instance, 'secret')
|
||||
instance = Mock(data={"name": "test", "db_type": -1})
|
||||
handle_dbuser_password_set(Mock(name="sender"), instance, "secret")
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_handle_dbuser_create_unknown(self):
|
||||
instance = Mock(data={'name': 'test', 'db_type': -1})
|
||||
handle_dbuser_created(
|
||||
Mock(name='sender'), instance, True, password='secret')
|
||||
instance = Mock(data={"name": "test", "db_type": -1})
|
||||
handle_dbuser_created(Mock(name="sender"), instance, True, password="secret")
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_handle_dbuser_deleted_unknown(self):
|
||||
instance = Mock(data={'name': 'test', 'db_type': -1})
|
||||
handle_dbuser_deleted(Mock(name='sender'), instance)
|
||||
instance = Mock(data={"name": "test", "db_type": -1})
|
||||
handle_dbuser_deleted(Mock(name="sender"), instance)
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_handle_userdb_created_unknown(self):
|
||||
instance = Mock(
|
||||
data={
|
||||
'db_name': 'test',
|
||||
'db_user': Mock(data={'name': 'test', 'db_type': -1, })
|
||||
})
|
||||
handle_userdb_created(Mock(name='sender'), instance, True)
|
||||
"db_name": "test",
|
||||
"db_user": Mock(data={"name": "test", "db_type": -1}),
|
||||
}
|
||||
)
|
||||
handle_userdb_created(Mock(name="sender"), instance, True)
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
||||
def test_handle_userdb_deleted_unknown(self):
|
||||
instance = Mock(
|
||||
data={
|
||||
'db_name': 'test',
|
||||
'db_user': Mock(data={'name': 'test', 'db_type': -1, })
|
||||
})
|
||||
handle_userdb_deleted(Mock(name='sender'), instance)
|
||||
"db_name": "test",
|
||||
"db_user": Mock(data={"name": "test", "db_type": -1}),
|
||||
}
|
||||
)
|
||||
handle_userdb_deleted(Mock(name="sender"), instance)
|
||||
self.assertFalse(TaskResult.objects.exists())
|
||||
|
|
|
|||
|
|
@ -2,16 +2,11 @@
|
|||
This module provides tests for :py:mod:`userdbs.views`.
|
||||
|
||||
"""
|
||||
from __future__ import absolute_import, unicode_literals
|
||||
from unittest.mock import patch, MagicMock
|
||||
|
||||
try:
|
||||
from unittest.mock import patch, MagicMock
|
||||
except ImportError:
|
||||
from mock import patch, MagicMock
|
||||
|
||||
from django.core.urlresolvers import reverse
|
||||
from django.test import TestCase
|
||||
from django.contrib.auth import get_user_model
|
||||
from django.urls import reverse
|
||||
|
||||
from hostingpackages.models import (
|
||||
CustomerHostingPackage,
|
||||
|
|
@ -26,58 +21,61 @@ from userdbs.views import AddUserDatabase, ChangeDatabaseUserPassword
|
|||
|
||||
User = get_user_model()
|
||||
|
||||
TEST_USER = 'test'
|
||||
TEST_PASSWORD = 'secret'
|
||||
TEST_EMAIL = 'test@example.org'
|
||||
TEST_USER = "test"
|
||||
TEST_PASSWORD = "secret"
|
||||
TEST_EMAIL = "test@example.org"
|
||||
|
||||
|
||||
class HostingPackageAwareTestMixin(object):
|
||||
|
||||
# noinspection PyMethodMayBeStatic
|
||||
def _setup_hosting_package(self, customer):
|
||||
template = HostingPackageTemplate.objects.create(
|
||||
name='testpackagetemplate', mailboxcount=10, diskspace=1,
|
||||
diskspace_unit=0)
|
||||
name="testpackagetemplate", mailboxcount=10, diskspace=1, diskspace_unit=0
|
||||
)
|
||||
package = CustomerHostingPackage.objects.create_from_template(
|
||||
customer, template, 'testpackage')
|
||||
with patch('hostingpackages.models.settings') as hmsettings:
|
||||
customer, template, "testpackage"
|
||||
)
|
||||
with patch("hostingpackages.models.settings") as hmsettings:
|
||||
hmsettings.OSUSER_DEFAULT_GROUPS = []
|
||||
package.save()
|
||||
return package
|
||||
|
||||
|
||||
class CustomerUserDatabaseOptionAwareTestMixin(object):
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
super(CustomerUserDatabaseOptionAwareTestMixin, self).__init__(
|
||||
*args, **kwargs)
|
||||
super(CustomerUserDatabaseOptionAwareTestMixin, self).__init__(*args, **kwargs)
|
||||
self._templates = {}
|
||||
|
||||
def _setup_userdatabaseoption(self, number, dbtype):
|
||||
key = "{}_{}".format(dbtype, number)
|
||||
if key not in self._templates:
|
||||
self._templates[key] = UserDatabaseOption.objects.create(
|
||||
number=number, db_type=dbtype)
|
||||
number=number, db_type=dbtype
|
||||
)
|
||||
return self._templates[key]
|
||||
|
||||
def _create_userdatabase_option(self, number=1, dbtype=DB_TYPES.pgsql):
|
||||
# noinspection PyUnresolvedReferences
|
||||
return CustomerUserDatabaseOption.objects.create(
|
||||
template=self._setup_userdatabaseoption(number, dbtype),
|
||||
number=number, db_type=dbtype, hosting_package=self.package)
|
||||
number=number,
|
||||
db_type=dbtype,
|
||||
hosting_package=self.package,
|
||||
)
|
||||
|
||||
|
||||
class AddUserDatabaseTest(
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin,
|
||||
TestCase
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin, TestCase
|
||||
):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
|
||||
def _get_url(self):
|
||||
return reverse(
|
||||
'add_userdatabase', kwargs={'package': self.package.id})
|
||||
return reverse("add_userdatabase", kwargs={"package": self.package.id})
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url())
|
||||
|
|
@ -95,31 +93,29 @@ class AddUserDatabaseTest(
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user_nodboption(self):
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 400)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
self._create_userdatabase_option()
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_regular_user_nofree_db(self):
|
||||
db_option = self._create_userdatabase_option()
|
||||
UserDatabase.objects.create_userdatabase_with_user(
|
||||
db_option.db_type, self.package.osuser)
|
||||
db_option.db_type, self.package.osuser
|
||||
)
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertEqual(response.status_code, 400)
|
||||
|
|
@ -128,21 +124,21 @@ class AddUserDatabaseTest(
|
|||
db_option = self._create_userdatabase_option()
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
view = AddUserDatabase(
|
||||
request=MagicMock(), kwargs={'package': str(self.package.pk)})
|
||||
request=MagicMock(), kwargs={"package": str(self.package.pk)}
|
||||
)
|
||||
the_kwargs = view.get_form_kwargs()
|
||||
self.assertIn('hostingpackage', the_kwargs)
|
||||
self.assertEqual(the_kwargs['hostingpackage'], self.package)
|
||||
self.assertIn('dbtypes', the_kwargs)
|
||||
self.assertIn("hostingpackage", the_kwargs)
|
||||
self.assertEqual(the_kwargs["hostingpackage"], self.package)
|
||||
self.assertIn("dbtypes", the_kwargs)
|
||||
self.assertEqual(
|
||||
the_kwargs['dbtypes'],
|
||||
[(db_option.db_type, DB_TYPES[db_option.db_type])],
|
||||
the_kwargs["dbtypes"], [(db_option.db_type, DB_TYPES[db_option.db_type])]
|
||||
)
|
||||
|
||||
def test_get_template(self):
|
||||
self._create_userdatabase_option()
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url())
|
||||
self.assertTemplateUsed(response, 'userdbs/userdatabase_create.html')
|
||||
self.assertTemplateUsed(response, "userdbs/userdatabase_create.html")
|
||||
|
||||
def test_form_valid_redirect(self):
|
||||
db_option = self._create_userdatabase_option()
|
||||
|
|
@ -150,48 +146,55 @@ class AddUserDatabaseTest(
|
|||
response = self.client.post(
|
||||
self._get_url(),
|
||||
data={
|
||||
'db_type': db_option.db_type, 'password1': TEST_PASSWORD,
|
||||
'password2': TEST_PASSWORD})
|
||||
"db_type": db_option.db_type,
|
||||
"password1": TEST_PASSWORD,
|
||||
"password2": TEST_PASSWORD,
|
||||
},
|
||||
)
|
||||
self.assertRedirects(response, self.package.get_absolute_url())
|
||||
|
||||
def test_form_valid_message(self):
|
||||
db_option = self._create_userdatabase_option()
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
self._get_url(), follow=True,
|
||||
self._get_url(),
|
||||
follow=True,
|
||||
data={
|
||||
'db_type': db_option.db_type, 'password1': TEST_PASSWORD,
|
||||
'password2': TEST_PASSWORD})
|
||||
db = UserDatabase.objects.filter(
|
||||
db_user__osuser=self.package.osuser).get()
|
||||
messages = list(response.context['messages'])
|
||||
"db_type": db_option.db_type,
|
||||
"password1": TEST_PASSWORD,
|
||||
"password2": TEST_PASSWORD,
|
||||
},
|
||||
)
|
||||
db = UserDatabase.objects.filter(db_user__osuser=self.package.osuser).get()
|
||||
messages = list(response.context["messages"])
|
||||
self.assertEqual(len(messages), 1)
|
||||
self.assertEqual(
|
||||
str(messages[0]), (
|
||||
'Successfully create new {type} database {dbname} for user '
|
||||
'{dbuser}.').format(
|
||||
type=db.db_user.db_type, dbname=db.db_name,
|
||||
dbuser=db.db_user))
|
||||
str(messages[0]),
|
||||
(
|
||||
"Successfully create new {type} database {dbname} for user " "{dbuser}."
|
||||
).format(type=db.db_user.db_type, dbname=db.db_name, dbuser=db.db_user),
|
||||
)
|
||||
|
||||
|
||||
class ChangeDatabaseUserPasswordTest(
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin,
|
||||
TestCase
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin, TestCase
|
||||
):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
template = self._create_userdatabase_option()
|
||||
database = UserDatabase.objects.create_userdatabase_with_user(
|
||||
template.db_type, self.package.osuser)
|
||||
template.db_type, self.package.osuser
|
||||
)
|
||||
self.dbuser = database.db_user
|
||||
|
||||
def _get_url(self, dbuser):
|
||||
return reverse(
|
||||
'change_dbuser_password', kwargs={
|
||||
'package': self.package.id, 'slug': dbuser.name})
|
||||
"change_dbuser_password",
|
||||
kwargs={"package": self.package.id, "slug": dbuser.name},
|
||||
)
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
|
|
@ -203,80 +206,85 @@ class ChangeDatabaseUserPasswordTest(
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
self.assertTemplateUsed(
|
||||
response, 'userdbs/databaseuser_setpassword.html')
|
||||
self.assertTemplateUsed(response, "userdbs/databaseuser_setpassword.html")
|
||||
|
||||
def test_get_form_kwargs(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
view = ChangeDatabaseUserPassword(request=MagicMock(), kwargs={
|
||||
'package': str(self.package.pk), 'slug': self.dbuser.name})
|
||||
view = ChangeDatabaseUserPassword(
|
||||
request=MagicMock(),
|
||||
kwargs={"package": str(self.package.pk), "slug": self.dbuser.name},
|
||||
)
|
||||
the_kwargs = view.get_form_kwargs()
|
||||
self.assertIn('hostingpackage', the_kwargs)
|
||||
self.assertEqual(the_kwargs['hostingpackage'], self.package)
|
||||
self.assertIn("hostingpackage", the_kwargs)
|
||||
self.assertEqual(the_kwargs["hostingpackage"], self.package)
|
||||
|
||||
def test_get_context_data(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.dbuser))
|
||||
self.assertIn('dbuser', response.context)
|
||||
self.assertEqual(response.context['dbuser'], self.dbuser)
|
||||
self.assertIn('hostingpackage', response.context)
|
||||
self.assertEqual(response.context['hostingpackage'], self.package)
|
||||
self.assertIn('customer', response.context)
|
||||
self.assertEqual(response.context['customer'], self.customer)
|
||||
self.assertIn("dbuser", response.context)
|
||||
self.assertEqual(response.context["dbuser"], self.dbuser)
|
||||
self.assertIn("hostingpackage", response.context)
|
||||
self.assertEqual(response.context["hostingpackage"], self.package)
|
||||
self.assertIn("customer", response.context)
|
||||
self.assertEqual(response.context["customer"], self.customer)
|
||||
|
||||
def test_form_valid_redirect(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(self._get_url(self.dbuser), data={
|
||||
'password1': TEST_PASSWORD, 'password2': TEST_PASSWORD})
|
||||
response = self.client.post(
|
||||
self._get_url(self.dbuser),
|
||||
data={"password1": TEST_PASSWORD, "password2": TEST_PASSWORD},
|
||||
)
|
||||
self.assertRedirects(response, self.package.get_absolute_url())
|
||||
|
||||
def test_form_valid_message(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(
|
||||
self._get_url(self.dbuser), follow=True, data={
|
||||
'password1': TEST_PASSWORD, 'password2': TEST_PASSWORD})
|
||||
messages = list(response.context['messages'])
|
||||
self._get_url(self.dbuser),
|
||||
follow=True,
|
||||
data={"password1": TEST_PASSWORD, "password2": TEST_PASSWORD},
|
||||
)
|
||||
messages = list(response.context["messages"])
|
||||
self.assertEqual(len(messages), 1)
|
||||
self.assertEqual(
|
||||
str(messages[0]),
|
||||
'Successfully changed password of database user {dbuser}.'.format(
|
||||
dbuser=self.dbuser.name))
|
||||
"Successfully changed password of database user {dbuser}.".format(
|
||||
dbuser=self.dbuser.name
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
class DeleteUserDatabaseTest(
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin,
|
||||
TestCase
|
||||
HostingPackageAwareTestMixin, CustomerUserDatabaseOptionAwareTestMixin, TestCase
|
||||
):
|
||||
|
||||
def setUp(self):
|
||||
self.customer = User.objects.create_user(
|
||||
username=TEST_USER, password=TEST_PASSWORD)
|
||||
username=TEST_USER, password=TEST_PASSWORD
|
||||
)
|
||||
self.package = self._setup_hosting_package(self.customer)
|
||||
template = self._create_userdatabase_option()
|
||||
self.database = UserDatabase.objects.create_userdatabase_with_user(
|
||||
template.db_type, self.package.osuser)
|
||||
template.db_type, self.package.osuser
|
||||
)
|
||||
|
||||
def _get_url(self, userdatabase):
|
||||
return reverse(
|
||||
'delete_userdatabase', kwargs={
|
||||
'package': self.package.id,
|
||||
'slug': userdatabase.db_name})
|
||||
"delete_userdatabase",
|
||||
kwargs={"package": self.package.id, "slug": userdatabase.db_name},
|
||||
)
|
||||
|
||||
def test_get_anonymous(self):
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
|
|
@ -288,34 +296,31 @@ class DeleteUserDatabaseTest(
|
|||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_other_regular_user(self):
|
||||
User.objects.create_user(
|
||||
'test2', password=TEST_PASSWORD)
|
||||
self.client.login(username='test2', password=TEST_PASSWORD)
|
||||
User.objects.create_user("test2", password=TEST_PASSWORD)
|
||||
self.client.login(username="test2", password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
self.assertEqual(response.status_code, 403)
|
||||
|
||||
def test_get_staff_user(self):
|
||||
User.objects.create_superuser(
|
||||
'admin', email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username='admin', password=TEST_PASSWORD)
|
||||
User.objects.create_superuser("admin", email=TEST_EMAIL, password=TEST_PASSWORD)
|
||||
self.client.login(username="admin", password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
self.assertEqual(response.status_code, 200)
|
||||
|
||||
def test_get_template(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
self.assertTemplateUsed(
|
||||
response, 'userdbs/userdatabase_confirm_delete.html')
|
||||
self.assertTemplateUsed(response, "userdbs/userdatabase_confirm_delete.html")
|
||||
|
||||
def test_get_context_data(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.get(self._get_url(self.database))
|
||||
self.assertIn('database', response.context)
|
||||
self.assertEqual(response.context['database'], self.database)
|
||||
self.assertIn('hostingpackage', response.context)
|
||||
self.assertEqual(response.context['hostingpackage'], self.package)
|
||||
self.assertIn('customer', response.context)
|
||||
self.assertEqual(response.context['customer'], self.customer)
|
||||
self.assertIn("database", response.context)
|
||||
self.assertEqual(response.context["database"], self.database)
|
||||
self.assertIn("hostingpackage", response.context)
|
||||
self.assertEqual(response.context["hostingpackage"], self.package)
|
||||
self.assertIn("customer", response.context)
|
||||
self.assertEqual(response.context["customer"], self.customer)
|
||||
|
||||
def test_form_valid_redirect(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
|
|
@ -325,6 +330,6 @@ class DeleteUserDatabaseTest(
|
|||
def test_form_valid_message(self):
|
||||
self.client.login(username=TEST_USER, password=TEST_PASSWORD)
|
||||
response = self.client.post(self._get_url(self.database), follow=True)
|
||||
messages = list(response.context['messages'])
|
||||
messages = list(response.context["messages"])
|
||||
self.assertEqual(len(messages), 1)
|
||||
self.assertEqual(str(messages[0]), "Database deleted.")
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue