def test_new_creation_deletion(self):
"Tests automatic creation/deletion for new tenant's save/delete"
self.assertFalse(schema_exists("tenant1"))
tenant = TenantModel(schema_name="tenant1")
tenant.save(verbosity=0)
self.assertTrue(schema_exists("tenant1"))
# Self-cleanup
tenant.delete(force_drop=True)
self.assertFalse(schema_exists("tenant1"))
def test_tenant_delete_callback(self):
TenantModel = get_tenant_model()
TenantModel.auto_create_schema = False
TenantModel.auto_drop_schema = True
tenant = TenantModel(schema_name="tenant1")
tenant.save()
tenant.create_schema(sync_schema=False)
self.assertTrue(schema_exists("tenant1"))
TenantModel.objects.all().delete()
self.assertFalse(schema_exists("tenant1"))
def test_create_drop_schema(self):
self.assertFalse(utils.create_schema(
"public", check_if_exists=True)) # Schema existed already
self.assertTrue(utils.schema_exists("public")) # Schema exists
self.assertTrue(utils.drop_schema("public")) # Schema was dropped
self.assertFalse(
utils.drop_schema("public")) # Schema no longer exists
self.assertFalse(utils.schema_exists("public")) # Schema doesn't exist
self.assertTrue(utils.create_schema(
"public", sync_schema=False)) # Schema was created
self.assertTrue(utils.schema_exists("public")) # Schema exists
def test_clone_schema(self):
utils._create_clone_schema_function()
self.assertFalse(
utils.schema_exists("sample2")) # Schema doesn't exist previously
utils.clone_schema("sample", "sample2", dry_run=True) # Dry run
self.assertFalse(
utils.schema_exists("sample2")) # Schema won't exist, dry run
utils.clone_schema("sample", "sample2") # Real run, schema was cloned
self.assertTrue(utils.schema_exists("sample2")) # Schema exists
with self.assertRaises(InternalError):
utils.clone_schema("sample",
"sample2") # Schema already exists, error
self.assertTrue(utils.schema_exists("sample2")) # Schema still exists
def test_existing_creation(self):
"Tests automatic creation for existing tenant's save"
self.assertFalse(schema_exists("tenant1"))
tenant = TenantModel(schema_name="tenant1")
tenant.auto_create_schema = False
tenant.save(verbosity=0)
self.assertFalse(schema_exists("tenant1"))
tenant.auto_create_schema = True
tenant.save(verbosity=0)
self.assertTrue(schema_exists("tenant1"))
# Self-cleanup
tenant.delete(force_drop=True)
self.assertFalse(schema_exists("tenant1"))
def test_createrefschema(self):
"Tests 'createrefschema' command"
utils.drop_schema("cloned")
call_command("createrefschema", verbosity=0) # All good
self.assertTrue(utils.schema_exists("sample"))
utils.drop_schema("cloned")
call_command("createrefschema", recreate=True,
verbosity=0) # All good too
self.assertTrue(utils.schema_exists("sample"))
utils.drop_schema("cloned")
call_command("createrefschema", recreate=True,
verbosity=0) # All good too
self.assertTrue(utils.schema_exists("sample"))
def test_new_aborted_creation(self):
"Tests recovery on automatic creation for new tenant's save"
def signal_receiver(*args, **kwargs):
raise Exception
self.assertFalse(schema_exists("tenant1"))
tenant = TenantModel(schema_name="tenant1")
dynamic_tenant_post_sync.connect(signal_receiver)
with self.assertRaises(Exception):
tenant.save(verbosity=0)
self.assertFalse(schema_exists("tenant1"))
self.assertEqual(0, TenantModel.objects.count())
dynamic_tenant_post_sync.disconnect(signal_receiver)
def test_cloneschema(self):
"Tests 'cloneschema' command"
utils._create_clone_schema_function()
self.assertFalse(utils.schema_exists("cloned"))
call_command("cloneschema", "sample", "cloned",
verbosity=0) # All good
self.assertTrue(utils.schema_exists("cloned"))
with self.assertRaises(CommandError): # Existing destination
call_command("cloneschema", "sample", "cloned", verbosity=0)
with self.assertRaises(CommandError): # Not existing source
call_command("cloneschema",
"nonexisting",
"newschema",
verbosity=0)
utils.drop_schema("cloned")
def test_existing_aborted_creation(self):
"Tests recovery on automatic creation for new tenant's save"
def signal_receiver(*args, **kwargs):
raise Exception
self.assertFalse(schema_exists("tenant1"))
tenant = TenantModel(schema_name="tenant1")
tenant.auto_create_schema = False
tenant.save(verbosity=0)
tenant.auto_create_schema = True
dynamic_tenant_post_sync.connect(signal_receiver)
with self.assertRaises(Exception):
tenant.save(verbosity=0)
self.assertFalse(schema_exists("tenant1"))
self.assertEqual(1, TenantModel.objects.count())
dynamic_tenant_post_sync.disconnect(signal_receiver)
# Self-cleanup
tenant.delete(force_drop=True)
self.assertEqual(0, TenantModel.objects.count())
def test_schema_exists(self):
self.assertTrue(utils.schema_exists("public"))
self.assertTrue(utils.schema_exists("www"))
self.assertTrue(utils.schema_exists("blog"))
self.assertTrue(utils.schema_exists("sample"))
self.assertFalse(utils.schema_exists("default"))
self.assertFalse(utils.schema_exists("tenant"))
def test_interactive_cloneschema(self):
answer_provider = (
n for n in [
"y", # Would you like to create a database entry?
"", # Domain name, simulated wrong answer
"tenant2.test.com", # Domain name, good answer
])
def patched_input(*args, **kwargs):
return next(answer_provider)
with patch("builtins.input", patched_input):
with StringIO() as stdout:
with StringIO() as stderr:
call_command("cloneschema",
"tenant1",
"tenant2",
verbosity=1,
stdout=stdout,
stderr=stderr)
self.assertTrue(utils.schema_exists("tenant2"))
