class TestDeleteDomain(TestCase):
def _create_data(self, domain_name, i):
product = Product(domain=domain_name, name='test-{}'.format(i))
product.save()
location = make_location(domain=domain_name,
site_code='testcode-{}'.format(i),
name='test-{}'.format(i),
location_type='facility')
location.save()
report = StockReport.objects.create(
type='balance',
domain=domain_name,
form_id='fake',
date=datetime.utcnow(),
server_date=datetime.utcnow(),
)
StockTransaction.objects.create(
report=report,
product_id=product.get_id,
sql_product=SQLProduct.objects.get(product_id=product.get_id),
section_id='stock',
type='stockonhand',
case_id=location.linked_supply_point().get_id,
stock_on_hand=100)
SMS.objects.create(domain=domain_name)
Call.objects.create(domain=domain_name)
SQLLastReadMessage.objects.create(domain=domain_name)
ExpectedCallback.objects.create(domain=domain_name)
PhoneNumber.objects.create(domain=domain_name,
is_two_way=False,
pending_verification=False)
event = MessagingEvent.objects.create(
domain=domain_name,
date=datetime.utcnow(),
source=MessagingEvent.SOURCE_REMINDER,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED)
MessagingSubEvent.objects.create(
parent=event,
date=datetime.utcnow(),
recipient_type=MessagingEvent.RECIPIENT_CASE,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED)
SelfRegistrationInvitation.objects.create(
domain=domain_name,
phone_number='999123',
token=uuid.uuid4().hex,
expiration_date=datetime.utcnow().date(),
created_date=datetime.utcnow())
backend = SQLMobileBackend.objects.create(domain=domain_name,
is_global=False)
SQLMobileBackendMapping.objects.create(
domain=domain_name,
backend_type=SQLMobileBackend.SMS,
prefix=str(i),
backend=backend)
MobileBackendInvitation.objects.create(domain=domain_name,
backend=backend)
def setUp(self):
super(TestDeleteDomain, self).setUp()
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain.convert_to_commtrack()
self.current_subscription = Subscription.new_domain_subscription(
BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by='tests')[0],
self.domain.name,
DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.ADVANCED),
date_start=date.today() - relativedelta(days=1),
)
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.domain2.convert_to_commtrack()
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
LocationType.objects.create(
domain='test',
name='facility2',
)
LocationType.objects.create(
domain='test2',
name='facility2',
)
def _assert_sql_counts(self, domain, number):
self.assertEqual(
StockTransaction.objects.filter(report__domain=domain).count(),
number)
self.assertEqual(
StockReport.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLLocation.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLProduct.objects.filter(domain=domain).count(), number)
self.assertEqual(
DocDomainMapping.objects.filter(domain_name=domain).count(),
number)
self.assertEqual(
LocationType.objects.filter(domain=domain).count(), number)
self.assertEqual(SMS.objects.filter(domain=domain).count(), number)
self.assertEqual(Call.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLLastReadMessage.objects.filter(domain=domain).count(), number)
self.assertEqual(
ExpectedCallback.objects.filter(domain=domain).count(), number)
self.assertEqual(
PhoneNumber.objects.filter(domain=domain).count(), number)
self.assertEqual(
MessagingEvent.objects.filter(domain=domain).count(), number)
self.assertEqual(
MessagingSubEvent.objects.filter(parent__domain=domain).count(),
number)
self.assertEqual(
SelfRegistrationInvitation.objects.filter(domain=domain).count(),
number)
self.assertEqual(
SQLMobileBackend.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLMobileBackendMapping.objects.filter(domain=domain).count(),
number)
self.assertEqual(
MobileBackendInvitation.objects.filter(domain=domain).count(),
number)
def test_sql_objects_deletion(self):
for i in range(2):
self._create_data('test', i)
self._create_data('test2', i)
self._assert_sql_counts('test', 2)
self._assert_sql_counts('test2', 2)
self.domain.delete()
self._assert_sql_counts('test', 0)
self._assert_sql_counts('test2', 2)
def test_active_subscription_terminated(self):
self.domain.delete()
terminated_subscription = Subscription.visible_objects.get(
subscriber__domain=self.domain.name)
self.assertFalse(terminated_subscription.is_active)
self.assertIsNotNone(terminated_subscription.date_end)
def test_accounting_future_subscription_suppressed(self):
self.current_subscription.date_end = self.current_subscription.date_start + relativedelta(
days=5)
self.current_subscription.save()
next_subscription = Subscription.new_domain_subscription(
self.current_subscription.account,
self.domain.name,
DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.PRO),
date_start=self.current_subscription.date_end,
)
self.domain.delete()
self.assertTrue(
Subscription.visible_and_suppressed_objects.get(
id=next_subscription.id).is_hidden_to_ops)
def test_active_subscription_credits_transferred_to_account(self):
credit_amount = random.randint(1, 10)
CreditLine.add_credit(
credit_amount,
feature_type=FeatureType.SMS,
subscription=self.current_subscription,
)
self.domain.delete()
# Check that get_credits_by_subscription_and_features does not return the old deactivated credit line
subscription_credits = CreditLine.get_credits_by_subscription_and_features(
self.current_subscription,
feature_type=FeatureType.SMS,
)
self.assertEqual(len(subscription_credits), 0)
# Check that old credit line has been tranferred to accoun
account_credits = CreditLine.get_credits_for_account(
self.current_subscription.account,
feature_type=FeatureType.SMS,
)
self.assertEqual(len(account_credits), 1)
self.assertEqual(account_credits[0].balance, Decimal(credit_amount))
@patch(
'corehq.apps.accounting.models.DomainDowngradeActionHandler.get_response'
)
def test_downgraded(self, mock_get_response):
mock_get_response.return_value = True
self.domain.delete()
self.assertEqual(len(mock_get_response.call_args_list), 1)
def _test_case_deletion(self):
for domain_name in [self.domain.name, self.domain2.name]:
CaseFactory(domain_name).create_case()
self.assertEqual(
len(CaseAccessors(domain_name).get_case_ids_in_domain()), 1)
self.domain.delete()
self.assertEqual(
len(CaseAccessors(self.domain.name).get_case_ids_in_domain()), 0)
self.assertEqual(
len(CaseAccessors(self.domain2.name).get_case_ids_in_domain()), 1)
@override_settings(TESTS_SHOULD_USE_SQL_BACKEND=True)
def test_case_deletion_sql(self):
self._test_case_deletion()
@override_settings(TESTS_SHOULD_USE_SQL_BACKEND=False)
def test_case_deletion_couch(self):
self._test_case_deletion()
@override_settings(TESTS_SHOULD_USE_SQL_BACKEND=True)
def test_form_deletion(self):
form_states = [
state_tuple[0] for state_tuple in XFormInstanceSQL.STATES
]
for domain_name in [self.domain.name, self.domain2.name]:
for form_state in form_states:
create_form_for_test(domain_name, state=form_state)
for doc_type in doc_type_to_state:
self.assertEqual(
len(
FormAccessors(domain_name).get_all_form_ids_in_domain(
doc_type=doc_type)), 1)
self.domain.delete()
for doc_type in doc_type_to_state:
self.assertEqual(
len(
FormAccessors(self.domain.name).get_all_form_ids_in_domain(
doc_type=doc_type)), 0)
self.assertEqual(
len(
FormAccessors(
self.domain2.name).get_all_form_ids_in_domain(
doc_type=doc_type)), 1)
def _assert_queryset_count(self, queryset_list, count):
for queryset in queryset_list:
self.assertEqual(queryset.count(), count)
def _assert_aggregate_ucr_count(self, domain_name, count):
self._assert_queryset_count([
AggregateTableDefinition.objects.filter(domain=domain_name),
PrimaryColumn.objects.filter(table_definition__domain=domain_name),
SecondaryTableDefinition.objects.filter(
table_definition__domain=domain_name),
SecondaryColumn.objects.filter(
table_definition__table_definition__domain=domain_name),
], count)
def test_aggregate_ucr_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
aggregate_table_definition = AggregateTableDefinition.objects.create(
domain=domain_name,
primary_data_source_id=uuid.uuid4(),
table_id=uuid.uuid4().hex,
)
secondary_table_definition = SecondaryTableDefinition.objects.create(
table_definition=aggregate_table_definition,
data_source_id=uuid.uuid4(),
)
PrimaryColumn.objects.create(
table_definition=aggregate_table_definition)
SecondaryColumn.objects.create(
table_definition=secondary_table_definition)
self._assert_aggregate_ucr_count(domain_name, 1)
self.domain.delete()
self._assert_aggregate_ucr_count(self.domain.name, 0)
self._assert_aggregate_ucr_count(self.domain2.name, 1)
self.assertEqual(SecondaryTableDefinition.objects.count(), 1)
self.assertEqual(
SecondaryTableDefinition.objects.filter(
table_definition__domain=self.domain2.name).count(), 1)
self.assertEqual(PrimaryColumn.objects.count(), 1)
self.assertEqual(
PrimaryColumn.objects.filter(
table_definition__domain=self.domain2.name).count(), 1)
self.assertEqual(SecondaryColumn.objects.count(), 1)
self.assertEqual(
SecondaryColumn.objects.filter(
table_definition__table_definition__domain=self.domain2.name).
count(), 1)
def _assert_case_importer_counts(self, domain_name, count):
self._assert_queryset_count([
CaseUploadFormRecord.objects.filter(
case_upload_record__domain=domain_name),
CaseUploadRecord.objects.filter(domain=domain_name),
], count)
def test_case_importer(self):
for domain_name in [self.domain.name, self.domain2.name]:
case_upload_record = CaseUploadRecord.objects.create(
domain=domain_name,
task_id=uuid.uuid4().hex,
upload_id=uuid.uuid4().hex,
)
CaseUploadFormRecord.objects.create(
case_upload_record=case_upload_record,
form_id=uuid.uuid4().hex,
)
self._assert_case_importer_counts(domain_name, 1)
self.domain.delete()
self._assert_case_importer_counts(self.domain.name, 0)
self._assert_case_importer_counts(self.domain2.name, 1)
self.assertEqual(CaseUploadFormRecord.objects.count(), 1)
self.assertEqual(
CaseUploadFormRecord.objects.filter(
case_upload_record__domain=self.domain2.name).count(), 1)
def _assert_case_search_counts(self, domain_name, count):
self._assert_queryset_count([
CaseSearchConfig.objects.filter(domain=domain_name),
CaseSearchQueryAddition.objects.filter(domain=domain_name),
FuzzyProperties.objects.filter(domain=domain_name),
IgnorePatterns.objects.filter(domain=domain_name),
], count)
def test_case_search(self):
for domain_name in [self.domain.name, self.domain2.name]:
CaseSearchConfig.objects.create(domain=domain_name)
CaseSearchQueryAddition.objects.create(domain=domain_name)
FuzzyProperties.objects.create(domain=domain_name)
IgnorePatterns.objects.create(domain=domain_name)
self._assert_case_search_counts(domain_name, 1)
self.domain.delete()
self._assert_case_search_counts(self.domain.name, 0)
self._assert_case_search_counts(self.domain2.name, 1)
def _assert_data_analytics_counts(self, domain_name, count):
self._assert_queryset_count([
GIRRow.objects.filter(domain_name=domain_name),
MALTRow.objects.filter(domain_name=domain_name),
], count)
def test_data_analytics(self):
for domain_name in [self.domain.name, self.domain2.name]:
GIRRow.objects.create(
domain_name=domain_name,
month=date.today(),
start_date=date.today(),
wams_current=1,
active_users=1,
using_and_performing=1,
not_performing=1,
inactive_experienced=1,
inactive_not_experienced=1,
not_experienced=1,
not_performing_not_experienced=1,
active_ever=1,
possibly_exp=1,
ever_exp=1,
exp_and_active_ever=1,
active_in_span=1,
eligible_forms=1,
)
MALTRow.objects.create(
domain_name=domain_name,
month=date.today(),
num_of_forms=1,
)
self._assert_data_analytics_counts(domain_name, 1)
self.domain.delete()
self._assert_data_analytics_counts(self.domain.name, 0)
self._assert_data_analytics_counts(self.domain2.name, 1)
def _assert_data_dictionary_counts(self, domain_name, count):
self._assert_queryset_count([
CaseType.objects.filter(domain=domain_name),
CaseProperty.objects.filter(case_type__domain=domain_name),
], count)
def test_data_dictionary(self):
for domain_name in [self.domain.name, self.domain2.name]:
case_type = CaseType.objects.create(domain=domain_name,
name='case_type')
CaseProperty.objects.create(case_type=case_type,
name='case_property')
self._assert_data_dictionary_counts(domain_name, 1)
self.domain.delete()
self._assert_data_dictionary_counts(self.domain.name, 0)
self._assert_data_dictionary_counts(self.domain2.name, 1)
def _assert_data_interfaces(self, domain_name, count):
self._assert_queryset_count([
AutomaticUpdateRule.objects.filter(domain=domain_name),
CaseRuleAction.objects.filter(rule__domain=domain_name),
CaseRuleCriteria.objects.filter(rule__domain=domain_name),
CaseRuleSubmission.objects.filter(domain=domain_name),
DomainCaseRuleRun.objects.filter(domain=domain_name),
], count)
def test_data_interfaces(self):
for domain_name in [self.domain.name, self.domain2.name]:
automatic_update_rule = AutomaticUpdateRule.objects.create(
domain=domain_name)
CaseRuleAction.objects.create(rule=automatic_update_rule)
CaseRuleCriteria.objects.create(rule=automatic_update_rule)
CaseRuleSubmission.objects.create(
created_on=datetime.utcnow(),
domain=domain_name,
form_id=uuid.uuid4().hex,
rule=automatic_update_rule,
)
DomainCaseRuleRun.objects.create(domain=domain_name,
started_on=datetime.utcnow())
self._assert_data_interfaces(domain_name, 1)
self.domain.delete()
self._assert_data_interfaces(self.domain.name, 0)
self._assert_data_interfaces(self.domain2.name, 1)
self.assertEqual(CaseRuleAction.objects.count(), 1)
self.assertEqual(
CaseRuleAction.objects.filter(
rule__domain=self.domain2.name).count(), 1)
self.assertEqual(CaseRuleCriteria.objects.count(), 1)
self.assertEqual(
CaseRuleCriteria.objects.filter(
rule__domain=self.domain2.name).count(), 1)
def _assert_domain_counts(self, domain_name, count):
self._assert_queryset_count([
TransferDomainRequest.objects.filter(domain=domain_name),
], count)
def test_delete_domain(self):
for domain_name in [self.domain.name, self.domain2.name]:
TransferDomainRequest.objects.create(domain=domain_name,
to_username='******',
from_username='******')
self._assert_domain_counts(domain_name, 1)
self.domain.delete()
self._assert_domain_counts(self.domain.name, 0)
self._assert_domain_counts(self.domain2.name, 1)
def _assert_export_counts(self, domain_name, count):
self._assert_queryset_count([
DataFile.meta_query(domain_name),
EmailExportWhenDoneRequest.objects.filter(domain=domain_name),
], count)
def test_export_delete(self):
blobdb = get_blob_db()
data_files = []
for domain_name in [self.domain.name, self.domain2.name]:
data_files.append(
DataFile.save_blob(
BytesIO((domain_name + " csv").encode('utf-8')),
domain=domain_name,
filename="data.csv",
description="data file",
content_type="text/csv",
delete_after=datetime.utcnow() + timedelta(minutes=10),
))
EmailExportWhenDoneRequest.objects.create(domain=domain_name)
self._assert_export_counts(domain_name, 1)
self.domain.delete()
with self.assertRaises(NotFound):
blobdb.get(key=data_files[0].blob_id)
with blobdb.get(key=data_files[1].blob_id) as f:
self.assertEqual(f.read(),
(self.domain2.name + " csv").encode('utf-8'))
self._assert_export_counts(self.domain.name, 0)
self._assert_export_counts(self.domain2.name, 1)
def _assert_location_counts(self, domain_name, count):
self._assert_queryset_count(
[LocationFixtureConfiguration.objects.filter(domain=domain_name)],
count)
def test_location_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
LocationFixtureConfiguration.objects.create(domain=domain_name)
self._assert_location_counts(domain_name, 1)
self.domain.delete()
self._assert_location_counts(self.domain.name, 0)
self._assert_location_counts(self.domain2.name, 1)
def _assert_ota_counts(self, domain_name, count):
self._assert_queryset_count([
MobileRecoveryMeasure.objects.filter(domain=domain_name),
SerialIdBucket.objects.filter(domain=domain_name),
], count)
def test_ota_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
MobileRecoveryMeasure.objects.create(domain=domain_name)
SerialIdBucket.objects.create(domain=domain_name)
self._assert_ota_counts(domain_name, 1)
self.domain.delete()
self._assert_ota_counts(self.domain.name, 0)
self._assert_ota_counts(self.domain2.name, 1)
def _assert_reports_counts(self, domain_name, count):
self._assert_queryset_count(
[ReportsSidebarOrdering.objects.filter(domain=domain_name)], count)
def test_reports_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
ReportsSidebarOrdering.objects.create(domain=domain_name)
self._assert_reports_counts(domain_name, 1)
self.domain.delete()
self._assert_reports_counts(self.domain.name, 0)
self._assert_reports_counts(self.domain2.name, 1)
def _assert_phone_counts(self, domain_name, count):
self._assert_queryset_count([
OwnershipCleanlinessFlag.objects.filter(domain=domain_name),
SyncLogSQL.objects.filter(domain=domain_name)
], count)
def test_phone_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
OwnershipCleanlinessFlag.objects.create(domain=domain_name)
SyncLogSQL.objects.create(
domain=domain_name,
doc={},
synclog_id=uuid.uuid4(),
user_id=uuid.uuid4(),
)
self._assert_phone_counts(domain_name, 1)
self.domain.delete()
self._assert_phone_counts(self.domain.name, 0)
self._assert_phone_counts(self.domain2.name, 1)
def _assert_reminders_counts(self, domain_name, count):
self._assert_queryset_count([
EmailUsage.objects.filter(domain=domain_name),
], count)
def test_reminders_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
EmailUsage.objects.create(domain=domain_name, month=7, year=2018)
self._assert_reminders_counts(domain_name, 1)
self.domain.delete()
self._assert_reminders_counts(self.domain.name, 0)
self._assert_reminders_counts(self.domain2.name, 1)
def _assert_sms_counts(self, domain_name, count):
self._assert_queryset_count([
DailyOutboundSMSLimitReached.objects.filter(domain=domain_name),
Keyword.objects.filter(domain=domain_name),
KeywordAction.objects.filter(keyword__domain=domain_name),
QueuedSMS.objects.filter(domain=domain_name)
], count)
def test_sms_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
DailyOutboundSMSLimitReached.objects.create(domain=domain_name,
date=date.today())
keyword = Keyword.objects.create(domain=domain_name)
KeywordAction.objects.create(keyword=keyword)
QueuedSMS.objects.create(domain=domain_name)
self._assert_sms_counts(domain_name, 1)
self.domain.delete()
self._assert_sms_counts(self.domain.name, 0)
self._assert_sms_counts(self.domain2.name, 1)
self.assertEqual(KeywordAction.objects.count(), 1)
self.assertEqual(
KeywordAction.objects.filter(
keyword__domain=self.domain2.name).count(), 1)
def _assert_smsforms_counts(self, domain_name, count):
self._assert_queryset_count([
SQLXFormsSession.objects.filter(domain=domain_name),
], count)
def test_smsforms_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
SQLXFormsSession.objects.create(
domain=domain_name,
start_time=datetime.utcnow(),
modified_time=datetime.utcnow(),
current_action_due=datetime.utcnow(),
expire_after=3,
)
self._assert_smsforms_counts(domain_name, 1)
self.domain.delete()
self._assert_smsforms_counts(self.domain.name, 0)
self._assert_smsforms_counts(self.domain2.name, 1)
def _assert_userreports_counts(self, domain_name, count):
self._assert_queryset_count(
[AsyncIndicator.objects.filter(domain=domain_name)], count)
def test_userreports_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
AsyncIndicator.objects.create(
domain=domain_name,
doc_id=uuid.uuid4().hex,
doc_type='doc_type',
indicator_config_ids=[],
)
self._assert_userreports_counts(domain_name, 1)
self.domain.delete()
self._assert_userreports_counts(self.domain.name, 0)
self._assert_userreports_counts(self.domain2.name, 1)
def _assert_users_counts(self, domain_name, count):
self._assert_queryset_count([
DomainRequest.objects.filter(domain=domain_name),
], count)
def test_users_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
DomainRequest.objects.create(domain=domain_name,
email='*****@*****.**',
full_name='User')
self._assert_users_counts(domain_name, 1)
self.domain.delete()
self._assert_users_counts(self.domain.name, 0)
self._assert_users_counts(self.domain2.name, 1)
def _assert_zapier_counts(self, domain_name, count):
self._assert_queryset_count([
ZapierSubscription.objects.filter(domain=domain_name),
], count)
def test_zapier_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
ZapierSubscription.objects.create(
domain=domain_name,
case_type='case_type',
event_name=EventTypes.NEW_CASE,
url='http://%s.com' % domain_name,
user_id='user_id',
)
self._assert_zapier_counts(domain_name, 1)
self.domain.delete()
self._assert_zapier_counts(self.domain.name, 0)
self._assert_zapier_counts(self.domain2.name, 1)
def _assert_motech_count(self, domain_name, count):
self._assert_queryset_count([
RequestLog.objects.filter(domain=domain_name),
], count)
def test_motech_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
RequestLog.objects.create(domain=domain_name)
self._assert_motech_count(domain_name, 1)
self.domain.delete()
self._assert_motech_count(self.domain.name, 0)
self._assert_motech_count(self.domain2.name, 1)
def _assert_couchforms_counts(self, domain_name, count):
self._assert_queryset_count(
[UnfinishedSubmissionStub.objects.filter(domain=domain_name)],
count)
def test_couchforms_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
UnfinishedSubmissionStub.objects.create(
domain=domain_name,
timestamp=datetime.utcnow(),
xform_id='xform_id',
)
self._assert_couchforms_counts(domain_name, 1)
self.domain.delete()
self._assert_couchforms_counts(self.domain.name, 0)
self._assert_couchforms_counts(self.domain2.name, 1)
def test_delete_commtrack_config(self):
CommtrackConfig(domain=self.domain.name).save()
self.domain.delete()
self.assertEqual(
len(get_docs_in_domain_by_class(self.domain.name,
CommtrackConfig)), 0)
def tearDown(self):
self.domain2.delete()
super(TestDeleteDomain, self).tearDown()
class TestDeleteDomain(TestCase):
def _create_data(self, domain_name, i):
product = Product(domain=domain_name, name='test-{}'.format(i))
product.save()
location = make_location(
domain=domain_name,
site_code='testcode-{}'.format(i),
name='test-{}'.format(i),
location_type='facility'
)
location.save()
report = StockReport.objects.create(
type='balance',
domain=domain_name,
form_id='fake',
date=datetime.utcnow(),
server_date=datetime.utcnow(),
)
StockTransaction.objects.create(
report=report,
product_id=product.get_id,
sql_product=SQLProduct.objects.get(product_id=product.get_id),
section_id='stock',
type='stockonhand',
case_id=location.linked_supply_point().get_id,
stock_on_hand=100
)
SMS.objects.create(domain=domain_name)
Call.objects.create(domain=domain_name)
SQLLastReadMessage.objects.create(domain=domain_name)
ExpectedCallback.objects.create(domain=domain_name)
PhoneNumber.objects.create(domain=domain_name, is_two_way=False, pending_verification=False)
event = MessagingEvent.objects.create(
domain=domain_name,
date=datetime.utcnow(),
source=MessagingEvent.SOURCE_REMINDER,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED
)
MessagingSubEvent.objects.create(
parent=event,
date=datetime.utcnow(),
recipient_type=MessagingEvent.RECIPIENT_CASE,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED
)
SelfRegistrationInvitation.objects.create(
domain=domain_name,
phone_number='999123',
token=uuid.uuid4().hex,
expiration_date=datetime.utcnow().date(),
created_date=datetime.utcnow()
)
backend = SQLMobileBackend.objects.create(domain=domain_name, is_global=False)
SQLMobileBackendMapping.objects.create(
domain=domain_name,
backend_type=SQLMobileBackend.SMS,
prefix=str(i),
backend=backend
)
MobileBackendInvitation.objects.create(domain=domain_name, backend=backend)
def setUp(self):
super(TestDeleteDomain, self).setUp()
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain.convert_to_commtrack()
self.current_subscription = Subscription.new_domain_subscription(
BillingAccount.get_or_create_account_by_domain(self.domain.name, created_by='tests')[0],
self.domain.name,
DefaultProductPlan.get_default_plan_version(SoftwarePlanEdition.ADVANCED),
date_start=date.today() - relativedelta(days=1),
)
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.domain2.convert_to_commtrack()
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
LocationType.objects.create(
domain='test',
name='facility2',
)
LocationType.objects.create(
domain='test2',
name='facility2',
)
def _assert_sql_counts(self, domain, number):
self.assertEqual(StockTransaction.objects.filter(report__domain=domain).count(), number)
self.assertEqual(StockReport.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLLocation.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLProduct.objects.filter(domain=domain).count(), number)
self.assertEqual(DocDomainMapping.objects.filter(domain_name=domain).count(), number)
self.assertEqual(LocationType.objects.filter(domain=domain).count(), number)
self.assertEqual(SMS.objects.filter(domain=domain).count(), number)
self.assertEqual(Call.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLLastReadMessage.objects.filter(domain=domain).count(), number)
self.assertEqual(ExpectedCallback.objects.filter(domain=domain).count(), number)
self.assertEqual(PhoneNumber.objects.filter(domain=domain).count(), number)
self.assertEqual(MessagingEvent.objects.filter(domain=domain).count(), number)
self.assertEqual(MessagingSubEvent.objects.filter(parent__domain=domain).count(), number)
self.assertEqual(SelfRegistrationInvitation.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLMobileBackend.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLMobileBackendMapping.objects.filter(domain=domain).count(), number)
self.assertEqual(MobileBackendInvitation.objects.filter(domain=domain).count(), number)
def test_sql_objects_deletion(self):
for i in range(2):
self._create_data('test', i)
self._create_data('test2', i)
self._assert_sql_counts('test', 2)
self._assert_sql_counts('test2', 2)
self.domain.delete()
self._assert_sql_counts('test', 0)
self._assert_sql_counts('test2', 2)
def test_active_subscription_terminated(self):
self.domain.delete()
terminated_subscription = Subscription.visible_objects.get(subscriber__domain=self.domain.name)
self.assertFalse(terminated_subscription.is_active)
self.assertIsNotNone(terminated_subscription.date_end)
def test_accounting_future_subscription_suppressed(self):
self.current_subscription.date_end = self.current_subscription.date_start + relativedelta(days=5)
self.current_subscription.save()
next_subscription = Subscription.new_domain_subscription(
self.current_subscription.account,
self.domain.name,
DefaultProductPlan.get_default_plan_version(edition=SoftwarePlanEdition.PRO),
date_start=self.current_subscription.date_end,
)
self.domain.delete()
self.assertTrue(
Subscription.visible_and_suppressed_objects.get(
id=next_subscription.id
).is_hidden_to_ops
)
def test_active_subscription_credits_transferred_to_account(self):
credit_amount = random.randint(1, 10)
CreditLine.add_credit(
credit_amount,
feature_type=FeatureType.SMS,
subscription=self.current_subscription,
)
self.domain.delete()
subscription_credits = CreditLine.get_credits_by_subscription_and_features(
self.current_subscription,
feature_type=FeatureType.SMS,
)
self.assertEqual(len(subscription_credits), 1)
self.assertEqual(subscription_credits[0].balance, Decimal('0.0000'))
account_credits = CreditLine.get_credits_for_account(
self.current_subscription.account,
feature_type=FeatureType.SMS,
)
self.assertEqual(len(account_credits), 1)
self.assertEqual(account_credits[0].balance, Decimal(credit_amount))
@patch('corehq.apps.accounting.models.DomainDowngradeActionHandler.get_response')
def test_downgraded(self, mock_get_response):
mock_get_response.return_value = True
self.domain.delete()
self.assertEqual(len(mock_get_response.call_args_list), 1)
def _test_case_deletion(self):
for domain_name in [self.domain.name, self.domain2.name]:
CaseFactory(domain_name).create_case()
self.assertEqual(len(CaseAccessors(domain_name).get_case_ids_in_domain()), 1)
self.domain.delete()
self.assertEqual(len(CaseAccessors(self.domain.name).get_case_ids_in_domain()), 0)
self.assertEqual(len(CaseAccessors(self.domain2.name).get_case_ids_in_domain()), 1)
@override_settings(TESTS_SHOULD_USE_SQL_BACKEND=True)
def test_case_deletion_sql(self):
self._test_case_deletion()
@override_settings(TESTS_SHOULD_USE_SQL_BACKEND=False)
def test_case_deletion_couch(self):
self._test_case_deletion()
@override_settings(TESTS_SHOULD_USE_SQL_BACKEND=True)
def test_form_deletion(self):
form_states = [state_tuple[0] for state_tuple in XFormInstanceSQL.STATES]
for domain_name in [self.domain.name, self.domain2.name]:
for form_state in form_states:
create_form_for_test(domain_name, state=form_state)
for doc_type in doc_type_to_state:
self.assertEqual(
len(FormAccessors(domain_name).get_all_form_ids_in_domain(doc_type=doc_type)),
1
)
self.domain.delete()
for doc_type in doc_type_to_state:
self.assertEqual(
len(FormAccessors(self.domain.name).get_all_form_ids_in_domain(doc_type=doc_type)),
0
)
self.assertEqual(
len(FormAccessors(self.domain2.name).get_all_form_ids_in_domain(doc_type=doc_type)),
1
)
def _assert_queryset_count(self, queryset_list, count):
for queryset in queryset_list:
self.assertEqual(queryset.count(), count)
def _assert_aggregate_ucr_count(self, domain_name, count):
self._assert_queryset_count([
AggregateTableDefinition.objects.filter(domain=domain_name),
PrimaryColumn.objects.filter(table_definition__domain=domain_name),
SecondaryTableDefinition.objects.filter(table_definition__domain=domain_name),
SecondaryColumn.objects.filter(table_definition__table_definition__domain=domain_name),
], count)
def test_aggregate_ucr_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
aggregate_table_definition = AggregateTableDefinition.objects.create(
domain=domain_name,
primary_data_source_id=uuid.uuid4(),
table_id=random_hex(),
)
secondary_table_definition = SecondaryTableDefinition.objects.create(
table_definition=aggregate_table_definition,
data_source_id=uuid.uuid4(),
)
PrimaryColumn.objects.create(table_definition=aggregate_table_definition)
SecondaryColumn.objects.create(table_definition=secondary_table_definition)
self._assert_aggregate_ucr_count(domain_name, 1)
self.domain.delete()
self._assert_aggregate_ucr_count(self.domain.name, 0)
self._assert_aggregate_ucr_count(self.domain2.name, 1)
self.assertEqual(SecondaryTableDefinition.objects.count(), 1)
self.assertEqual(
SecondaryTableDefinition.objects.filter(table_definition__domain=self.domain2.name).count(),
1
)
self.assertEqual(PrimaryColumn.objects.count(), 1)
self.assertEqual(PrimaryColumn.objects.filter(table_definition__domain=self.domain2.name).count(), 1)
self.assertEqual(SecondaryColumn.objects.count(), 1)
self.assertEqual(
SecondaryColumn.objects.filter(table_definition__table_definition__domain=self.domain2.name).count(),
1
)
def _assert_calendar_fixture_count(self, domain_name, count):
self._assert_queryset_count([
CalendarFixtureSettings.objects.filter(domain=domain_name)
], count)
def test_calendar_fixture_counts(self):
for domain_name in [self.domain.name, self.domain2.name]:
CalendarFixtureSettings.objects.create(domain=domain_name, days_before=3, days_after=4)
self._assert_calendar_fixture_count(domain_name, 1)
self.domain.delete()
self._assert_calendar_fixture_count(self.domain.name, 0)
self._assert_calendar_fixture_count(self.domain2.name, 1)
def _assert_case_importer_counts(self, domain_name, count):
self._assert_queryset_count([
CaseUploadFormRecord.objects.filter(case_upload_record__domain=domain_name),
CaseUploadRecord.objects.filter(domain=domain_name),
], count)
def test_case_importer(self):
for domain_name in [self.domain.name, self.domain2.name]:
case_upload_record = CaseUploadRecord.objects.create(
domain=domain_name,
task_id=uuid.uuid4().hex,
upload_id=uuid.uuid4().hex,
)
CaseUploadFormRecord.objects.create(
case_upload_record=case_upload_record,
form_id=random_hex(),
)
self._assert_case_importer_counts(domain_name, 1)
self.domain.delete()
self._assert_case_importer_counts(self.domain.name, 0)
self._assert_case_importer_counts(self.domain2.name, 1)
self.assertEqual(CaseUploadFormRecord.objects.count(), 1)
self.assertEqual(
CaseUploadFormRecord.objects.filter(case_upload_record__domain=self.domain2.name).count(),
1
)
def _assert_case_search_counts(self, domain_name, count):
self._assert_queryset_count([
CaseSearchConfig.objects.filter(domain=domain_name),
CaseSearchQueryAddition.objects.filter(domain=domain_name),
FuzzyProperties.objects.filter(domain=domain_name),
IgnorePatterns.objects.filter(domain=domain_name),
], count)
def test_case_search(self):
for domain_name in [self.domain.name, self.domain2.name]:
CaseSearchConfig.objects.create(domain=domain_name)
CaseSearchQueryAddition.objects.create(domain=domain_name)
FuzzyProperties.objects.create(domain=domain_name)
IgnorePatterns.objects.create(domain=domain_name)
self._assert_case_search_counts(domain_name, 1)
self.domain.delete()
self._assert_case_search_counts(self.domain.name, 0)
self._assert_case_search_counts(self.domain2.name, 1)
def _assert_data_analytics_counts(self, domain_name, count):
self._assert_queryset_count([
GIRRow.objects.filter(domain_name=domain_name),
MALTRow.objects.filter(domain_name=domain_name),
], count)
def test_data_analytics(self):
for domain_name in [self.domain.name, self.domain2.name]:
GIRRow.objects.create(
domain_name=domain_name,
month=date.today(),
start_date=date.today(),
wams_current=1,
active_users=1,
using_and_performing=1,
not_performing=1,
inactive_experienced=1,
inactive_not_experienced=1,
not_experienced=1,
not_performing_not_experienced=1,
active_ever=1,
possibly_exp=1,
ever_exp=1,
exp_and_active_ever=1,
active_in_span=1,
eligible_forms=1,
)
MALTRow.objects.create(
domain_name=domain_name,
month=date.today(),
num_of_forms=1,
)
self._assert_data_analytics_counts(domain_name, 1)
self.domain.delete()
self._assert_data_analytics_counts(self.domain.name, 0)
self._assert_data_analytics_counts(self.domain2.name, 1)
def _assert_data_dictionary_counts(self, domain_name, count):
self._assert_queryset_count([
CaseType.objects.filter(domain=domain_name),
CaseProperty.objects.filter(case_type__domain=domain_name),
], count)
def test_data_dictionary(self):
for domain_name in [self.domain.name, self.domain2.name]:
case_type = CaseType.objects.create(domain=domain_name, name='case_type')
CaseProperty.objects.create(case_type=case_type, name='case_property')
self._assert_data_dictionary_counts(domain_name, 1)
self.domain.delete()
self._assert_data_dictionary_counts(self.domain.name, 0)
self._assert_data_dictionary_counts(self.domain2.name, 1)
def _assert_data_interfaces(self, domain_name, count):
self._assert_queryset_count([
AutomaticUpdateRule.objects.filter(domain=domain_name),
CaseRuleAction.objects.filter(rule__domain=domain_name),
CaseRuleCriteria.objects.filter(rule__domain=domain_name),
CaseRuleSubmission.objects.filter(domain=domain_name),
DomainCaseRuleRun.objects.filter(domain=domain_name),
], count)
def test_data_interfaces(self):
for domain_name in [self.domain.name, self.domain2.name]:
automatic_update_rule = AutomaticUpdateRule.objects.create(domain=domain_name)
CaseRuleAction.objects.create(rule=automatic_update_rule)
CaseRuleCriteria.objects.create(rule=automatic_update_rule)
CaseRuleSubmission.objects.create(
created_on=datetime.utcnow(),
domain=domain_name,
form_id=random_hex(),
rule=automatic_update_rule,
)
DomainCaseRuleRun.objects.create(domain=domain_name, started_on=datetime.utcnow())
self._assert_data_interfaces(domain_name, 1)
self.domain.delete()
self._assert_data_interfaces(self.domain.name, 0)
self._assert_data_interfaces(self.domain2.name, 1)
self.assertEqual(CaseRuleAction.objects.count(), 1)
self.assertEqual(CaseRuleAction.objects.filter(rule__domain=self.domain2.name).count(), 1)
self.assertEqual(CaseRuleCriteria.objects.count(), 1)
self.assertEqual(CaseRuleCriteria.objects.filter(rule__domain=self.domain2.name).count(), 1)
def _assert_domain_counts(self, domain_name, count):
self._assert_queryset_count([
TransferDomainRequest.objects.filter(domain=domain_name),
], count)
def test_delete_domain(self):
for domain_name in [self.domain.name, self.domain2.name]:
TransferDomainRequest.objects.create(domain=domain_name, to_username='******', from_username='******')
self._assert_domain_counts(domain_name, 1)
self.domain.delete()
self._assert_domain_counts(self.domain.name, 0)
self._assert_domain_counts(self.domain2.name, 1)
def _assert_export_counts(self, domain_name, count):
self._assert_queryset_count([
DataFile.meta_query(domain_name),
EmailExportWhenDoneRequest.objects.filter(domain=domain_name),
], count)
def test_export_delete(self):
blobdb = get_blob_db()
data_files = []
for domain_name in [self.domain.name, self.domain2.name]:
data_files.append(DataFile.save_blob(
BytesIO((domain_name + " csv").encode('utf-8')),
domain=domain_name,
filename="data.csv",
description="data file",
content_type="text/csv",
delete_after=datetime.utcnow() + timedelta(minutes=10),
))
EmailExportWhenDoneRequest.objects.create(domain=domain_name)
self._assert_export_counts(domain_name, 1)
self.domain.delete()
with self.assertRaises(NotFound):
blobdb.get(key=data_files[0].blob_id)
with blobdb.get(key=data_files[1].blob_id) as f:
self.assertEqual(f.read(), (self.domain2.name + " csv").encode('utf-8'))
self._assert_export_counts(self.domain.name, 0)
self._assert_export_counts(self.domain2.name, 1)
def _assert_location_counts(self, domain_name, count):
self._assert_queryset_count([
LocationFixtureConfiguration.objects.filter(domain=domain_name)
], count)
def test_location_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
LocationFixtureConfiguration.objects.create(domain=domain_name)
self._assert_location_counts(domain_name, 1)
self.domain.delete()
self._assert_location_counts(self.domain.name, 0)
self._assert_location_counts(self.domain2.name, 1)
def _assert_ota_counts(self, domain_name, count):
self._assert_queryset_count([
MobileRecoveryMeasure.objects.filter(domain=domain_name),
SerialIdBucket.objects.filter(domain=domain_name),
], count)
def test_ota_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
MobileRecoveryMeasure.objects.create(domain=domain_name)
SerialIdBucket.objects.create(domain=domain_name)
self._assert_ota_counts(domain_name, 1)
self.domain.delete()
self._assert_ota_counts(self.domain.name, 0)
self._assert_ota_counts(self.domain2.name, 1)
def _assert_reports_counts(self, domain_name, count):
self._assert_queryset_count([
ReportsSidebarOrdering.objects.filter(domain=domain_name)
], count)
def test_reports_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
ReportsSidebarOrdering.objects.create(domain=domain_name)
self._assert_reports_counts(domain_name, 1)
self.domain.delete()
self._assert_reports_counts(self.domain.name, 0)
self._assert_reports_counts(self.domain2.name, 1)
def _assert_phone_counts(self, domain_name, count):
self._assert_queryset_count([
OwnershipCleanlinessFlag.objects.filter(domain=domain_name),
SyncLogSQL.objects.filter(domain=domain_name)
], count)
def test_phone_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
OwnershipCleanlinessFlag.objects.create(domain=domain_name)
SyncLogSQL.objects.create(
domain=domain_name,
doc={},
synclog_id=uuid.uuid4(),
user_id=uuid.uuid4(),
)
self._assert_phone_counts(domain_name, 1)
self.domain.delete()
self._assert_phone_counts(self.domain.name, 0)
self._assert_phone_counts(self.domain2.name, 1)
def _assert_reminders_counts(self, domain_name, count):
self._assert_queryset_count([
EmailUsage.objects.filter(domain=domain_name),
], count)
def test_reminders_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
EmailUsage.objects.create(domain=domain_name, month=7, year=2018)
self._assert_reminders_counts(domain_name, 1)
self.domain.delete()
self._assert_reminders_counts(self.domain.name, 0)
self._assert_reminders_counts(self.domain2.name, 1)
def _assert_sms_counts(self, domain_name, count):
self._assert_queryset_count([
DailyOutboundSMSLimitReached.objects.filter(domain=domain_name),
Keyword.objects.filter(domain=domain_name),
KeywordAction.objects.filter(keyword__domain=domain_name),
QueuedSMS.objects.filter(domain=domain_name)
], count)
def test_sms_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
DailyOutboundSMSLimitReached.objects.create(domain=domain_name, date=date.today())
keyword = Keyword.objects.create(domain=domain_name)
KeywordAction.objects.create(keyword=keyword)
QueuedSMS.objects.create(domain=domain_name)
self._assert_sms_counts(domain_name, 1)
self.domain.delete()
self._assert_sms_counts(self.domain.name, 0)
self._assert_sms_counts(self.domain2.name, 1)
self.assertEqual(KeywordAction.objects.count(), 1)
self.assertEqual(KeywordAction.objects.filter(keyword__domain=self.domain2.name).count(), 1)
def _assert_smsforms_counts(self, domain_name, count):
self._assert_queryset_count([
SQLXFormsSession.objects.filter(domain=domain_name),
], count)
def test_smsforms_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
SQLXFormsSession.objects.create(
domain=domain_name,
start_time=datetime.utcnow(),
modified_time=datetime.utcnow(),
current_action_due=datetime.utcnow(),
expire_after=3,
)
self._assert_smsforms_counts(domain_name, 1)
self.domain.delete()
self._assert_smsforms_counts(self.domain.name, 0)
self._assert_smsforms_counts(self.domain2.name, 1)
def _assert_userreports_counts(self, domain_name, count):
self._assert_queryset_count([
AsyncIndicator.objects.filter(domain=domain_name)
], count)
def test_userreports_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
AsyncIndicator.objects.create(
domain=domain_name,
doc_id=random_hex(),
doc_type='doc_type',
indicator_config_ids=[],
)
self._assert_userreports_counts(domain_name, 1)
self.domain.delete()
self._assert_userreports_counts(self.domain.name, 0)
self._assert_userreports_counts(self.domain2.name, 1)
def _assert_users_counts(self, domain_name, count):
self._assert_queryset_count([
DomainRequest.objects.filter(domain=domain_name),
], count)
def test_users_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
DomainRequest.objects.create(domain=domain_name, email='*****@*****.**', full_name='User')
self._assert_users_counts(domain_name, 1)
self.domain.delete()
self._assert_users_counts(self.domain.name, 0)
self._assert_users_counts(self.domain2.name, 1)
def _assert_zapier_counts(self, domain_name, count):
self._assert_queryset_count([
ZapierSubscription.objects.filter(domain=domain_name),
], count)
def test_zapier_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
ZapierSubscription.objects.create(
domain=domain_name,
case_type='case_type',
event_name=EventTypes.NEW_CASE,
url='http://%s.com' % domain_name,
user_id='user_id',
)
self._assert_zapier_counts(domain_name, 1)
self.domain.delete()
self._assert_zapier_counts(self.domain.name, 0)
self._assert_zapier_counts(self.domain2.name, 1)
def _assert_motech_count(self, domain_name, count):
self._assert_queryset_count([
RequestLog.objects.filter(domain=domain_name),
], count)
def test_motech_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
RequestLog.objects.create(domain=domain_name)
self._assert_motech_count(domain_name, 1)
self.domain.delete()
self._assert_motech_count(self.domain.name, 0)
self._assert_motech_count(self.domain2.name, 1)
def _assert_couchforms_counts(self, domain_name, count):
self._assert_queryset_count([
UnfinishedSubmissionStub.objects.filter(domain=domain_name)
], count)
def test_couchforms_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
UnfinishedSubmissionStub.objects.create(
domain=domain_name,
timestamp=datetime.utcnow(),
xform_id='xform_id',
)
self._assert_couchforms_counts(domain_name, 1)
self.domain.delete()
self._assert_couchforms_counts(self.domain.name, 0)
self._assert_couchforms_counts(self.domain2.name, 1)
def tearDown(self):
self.domain2.delete()
super(TestDeleteDomain, self).tearDown()
class TestDeleteDomain(TestCase):
def _create_data(self, domain_name, i):
product = Product(domain=domain_name, name='test-{}'.format(i))
product.save()
location = Location(
domain=domain_name,
site_code='testcode-{}'.format(i),
name='test-{}'.format(i),
location_type='facility'
)
location.save()
report = StockReport.objects.create(
type='balance',
domain=domain_name,
form_id='fake',
date=datetime.utcnow(),
server_date=datetime.utcnow(),
)
StockTransaction.objects.create(
report=report,
product_id=product.get_id,
sql_product=SQLProduct.objects.get(product_id=product.get_id),
section_id='stock',
type='stockonhand',
case_id=location.linked_supply_point().get_id,
stock_on_hand=100
)
SMS.objects.create(domain=domain_name)
Call.objects.create(domain=domain_name)
SQLLastReadMessage.objects.create(domain=domain_name)
ExpectedCallback.objects.create(domain=domain_name)
PhoneNumber.objects.create(domain=domain_name)
event = MessagingEvent.objects.create(
domain=domain_name,
date=datetime.utcnow(),
source=MessagingEvent.SOURCE_REMINDER,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED
)
MessagingSubEvent.objects.create(
parent=event,
date=datetime.utcnow(),
recipient_type=MessagingEvent.RECIPIENT_CASE,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED
)
SelfRegistrationInvitation.objects.create(
domain=domain_name,
phone_number='999123',
token=uuid.uuid4().hex,
expiration_date=datetime.utcnow().date(),
created_date=datetime.utcnow()
)
backend = SQLMobileBackend.objects.create(domain=domain_name, is_global=False)
SQLMobileBackendMapping.objects.create(
domain=domain_name,
backend_type=SQLMobileBackend.SMS,
prefix=str(i),
backend=backend
)
MobileBackendInvitation.objects.create(domain=domain_name, backend=backend)
def setUp(self):
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain.convert_to_commtrack()
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.domain2.convert_to_commtrack()
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
LocationType.objects.create(
domain='test',
name='facility2',
)
LocationType.objects.create(
domain='test2',
name='facility2',
)
for i in xrange(2):
self._create_data('test', i)
self._create_data('test2', i)
def _assert_sql_counts(self, domain, number):
self.assertEqual(StockTransaction.objects.filter(report__domain=domain).count(), number)
self.assertEqual(StockReport.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLLocation.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLProduct.objects.filter(domain=domain).count(), number)
self.assertEqual(DocDomainMapping.objects.filter(domain_name=domain).count(), number)
self.assertEqual(LocationType.objects.filter(domain=domain).count(), number)
self.assertEqual(SMS.objects.filter(domain=domain).count(), number)
self.assertEqual(Call.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLLastReadMessage.objects.filter(domain=domain).count(), number)
self.assertEqual(ExpectedCallback.objects.filter(domain=domain).count(), number)
self.assertEqual(PhoneNumber.objects.filter(domain=domain).count(), number)
self.assertEqual(MessagingEvent.objects.filter(domain=domain).count(), number)
self.assertEqual(MessagingSubEvent.objects.filter(parent__domain=domain).count(), number)
self.assertEqual(SelfRegistrationInvitation.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLMobileBackend.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLMobileBackendMapping.objects.filter(domain=domain).count(), number)
self.assertEqual(MobileBackendInvitation.objects.filter(domain=domain).count(), number)
def test_sql_objects_deletion(self):
self._assert_sql_counts('test', 2)
self._assert_sql_counts('test2', 2)
self.domain.delete()
self._assert_sql_counts('test', 0)
self._assert_sql_counts('test2', 2)
def tearDown(self):
self.domain2.delete()
def request_new_domain(request, form, org, domain_type=None, new_user=True):
now = datetime.utcnow()
current_user = CouchUser.from_django_user(request.user)
dom_req = RegistrationRequest()
if new_user:
dom_req.request_time = now
dom_req.request_ip = get_ip(request)
dom_req.activation_guid = uuid.uuid1().hex
name = form.cleaned_data['hr_name']
with CriticalSection(['request_domain_name_{}'.format(name)]):
name = Domain.generate_name(name)
new_domain = Domain(
name=name,
hr_name=form.cleaned_data['hr_name'],
is_active=False,
date_created=datetime.utcnow(),
creating_user=current_user.username,
secure_submissions=True,
)
if form.cleaned_data.get('domain_timezone'):
new_domain.default_timezone = form.cleaned_data['domain_timezone']
if org:
new_domain.organization = org
new_domain.hr_name = request.POST.get('domain_hrname', None) or new_domain.name
if not new_user:
new_domain.is_active = True
# ensure no duplicate domain documents get created on cloudant
new_domain.save(**get_safe_write_kwargs())
if domain_type == 'commtrack':
new_domain.convert_to_commtrack()
if not new_domain.name:
new_domain.name = new_domain._id
new_domain.save() # we need to get the name from the _id
create_30_day_trial(new_domain)
dom_req.domain = new_domain.name
if request.user.is_authenticated():
if not current_user:
current_user = WebUser()
current_user.sync_from_django_user(request.user)
current_user.save()
current_user.add_domain_membership(new_domain.name, is_admin=True)
current_user.save()
dom_req.requesting_user_username = request.user.username
dom_req.new_user_username = request.user.username
if new_user:
dom_req.save()
send_domain_registration_email(request.user.email,
dom_req.domain,
dom_req.activation_guid)
else:
send_global_domain_registration_email(request.user, new_domain.name)
send_new_request_update_email(request.user, get_ip(request), new_domain.name, is_new_user=new_user)
return new_domain.name
class TestDeleteDomain(TestCase):
def _create_data(self, domain_name, i):
product = Product(domain=domain_name, name='test-{}'.format(i))
product.save()
location = make_location(domain=domain_name,
site_code='testcode-{}'.format(i),
name='test-{}'.format(i),
location_type='facility')
location.save()
SMS.objects.create(domain=domain_name)
Call.objects.create(domain=domain_name)
SQLLastReadMessage.objects.create(domain=domain_name)
ExpectedCallback.objects.create(domain=domain_name)
PhoneNumber.objects.create(domain=domain_name,
is_two_way=False,
pending_verification=False)
event = MessagingEvent.objects.create(
domain=domain_name,
date=datetime.utcnow(),
source=MessagingEvent.SOURCE_REMINDER,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED)
MessagingSubEvent.objects.create(
parent=event,
date=datetime.utcnow(),
recipient_type=MessagingEvent.RECIPIENT_CASE,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED)
backend = SQLMobileBackend.objects.create(domain=domain_name,
is_global=False)
SQLMobileBackendMapping.objects.create(
domain=domain_name,
backend_type=SQLMobileBackend.SMS,
prefix=str(i),
backend=backend)
MobileBackendInvitation.objects.create(domain=domain_name,
backend=backend)
def setUp(self):
super(TestDeleteDomain, self).setUp()
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.addCleanup(ensure_deleted, self.domain)
self.domain.convert_to_commtrack()
self.current_subscription = Subscription.new_domain_subscription(
BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by='tests')[0],
self.domain.name,
get_product_plan_version(),
date_start=date.today() - relativedelta(days=1),
)
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.addCleanup(ensure_deleted, self.domain2)
self.domain2.convert_to_commtrack()
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
LocationType.objects.create(
domain='test',
name='facility2',
)
LocationType.objects.create(
domain='test2',
name='facility2',
)
def _assert_sql_counts(self, domain, number):
self.assertEqual(
SQLLocation.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLProduct.objects.filter(domain=domain).count(), number)
self.assertEqual(
LocationType.objects.filter(domain=domain).count(), number)
self.assertEqual(SMS.objects.filter(domain=domain).count(), number)
self.assertEqual(Call.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLLastReadMessage.objects.filter(domain=domain).count(), number)
self.assertEqual(
ExpectedCallback.objects.filter(domain=domain).count(), number)
self.assertEqual(
PhoneNumber.objects.filter(domain=domain).count(), number)
self.assertEqual(
MessagingEvent.objects.filter(domain=domain).count(), number)
self.assertEqual(
MessagingSubEvent.objects.filter(parent__domain=domain).count(),
number)
self.assertEqual(
SQLMobileBackend.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLMobileBackendMapping.objects.filter(domain=domain).count(),
number)
self.assertEqual(
MobileBackendInvitation.objects.filter(domain=domain).count(),
number)
def test_sql_objects_deletion(self):
for i in range(2):
self._create_data('test', i)
self._create_data('test2', i)
self._assert_sql_counts('test', 2)
self._assert_sql_counts('test2', 2)
self.domain.delete()
self._assert_sql_counts('test', 0)
self._assert_sql_counts('test2', 2)
def test_active_subscription_terminated(self):
self.domain.delete()
terminated_subscription = Subscription.visible_objects.get(
subscriber__domain=self.domain.name)
self.assertFalse(terminated_subscription.is_active)
self.assertIsNotNone(terminated_subscription.date_end)
def test_accounting_future_subscription_suppressed(self):
self.current_subscription.date_end = self.current_subscription.date_start + relativedelta(
days=5)
self.current_subscription.save()
next_subscription = Subscription.new_domain_subscription(
self.current_subscription.account,
self.domain.name,
DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.PRO),
date_start=self.current_subscription.date_end,
)
self.domain.delete()
self.assertTrue(
Subscription.visible_and_suppressed_objects.get(
id=next_subscription.id).is_hidden_to_ops)
def test_active_subscription_credits_transferred_to_account(self):
credit_amount = random.randint(1, 10)
CreditLine.add_credit(
credit_amount,
feature_type=FeatureType.SMS,
subscription=self.current_subscription,
)
self.domain.delete()
# Check that get_credits_by_subscription_and_features does not return the old deactivated credit line
subscription_credits = CreditLine.get_credits_by_subscription_and_features(
self.current_subscription,
feature_type=FeatureType.SMS,
)
self.assertEqual(len(subscription_credits), 0)
# Check that old credit line has been tranferred to accoun
account_credits = CreditLine.get_credits_for_account(
self.current_subscription.account,
feature_type=FeatureType.SMS,
)
self.assertEqual(len(account_credits), 1)
self.assertEqual(account_credits[0].balance, Decimal(credit_amount))
@patch(
'corehq.apps.accounting.models.DomainDowngradeActionHandler.get_response'
)
def test_downgraded(self, mock_get_response):
mock_get_response.return_value = True
self.domain.delete()
self.assertEqual(len(mock_get_response.call_args_list), 1)
def _test_case_deletion(self):
for domain_name in [self.domain.name, self.domain2.name]:
CaseFactory(domain_name).create_case()
self.assertEqual(
len(CommCareCase.objects.get_case_ids_in_domain(domain_name)),
1)
self.domain.delete()
self.assertEqual(
len(CommCareCase.objects.get_case_ids_in_domain(self.domain.name)),
0)
self.assertEqual(
len(CommCareCase.objects.get_case_ids_in_domain(
self.domain2.name)), 1)
def test_case_deletion_sql(self):
self._test_case_deletion()
def test_form_deletion(self):
form_states = [state_tuple[0] for state_tuple in XFormInstance.STATES]
for domain_name in [self.domain.name, self.domain2.name]:
for form_state in form_states:
create_form_for_test(domain_name, state=form_state)
for doc_type in doc_type_to_state:
self.assertEqual(
len(
XFormInstance.objects.get_form_ids_in_domain(
domain_name, doc_type=doc_type)), 1)
self.domain.delete()
for doc_type in doc_type_to_state:
self.assertEqual(
len(
XFormInstance.objects.get_form_ids_in_domain(
self.domain.name, doc_type=doc_type)), 0)
self.assertEqual(
len(
XFormInstance.objects.get_form_ids_in_domain(
self.domain2.name, doc_type=doc_type)), 1)
def _assert_queryset_count(self, queryset_list, count):
for queryset in queryset_list:
self.assertEqual(queryset.count(), count)
def _assert_aggregate_ucr_count(self, domain_name, count):
self._assert_queryset_count([
AggregateTableDefinition.objects.filter(domain=domain_name),
PrimaryColumn.objects.filter(table_definition__domain=domain_name),
SecondaryTableDefinition.objects.filter(
table_definition__domain=domain_name),
SecondaryColumn.objects.filter(
table_definition__table_definition__domain=domain_name),
], count)
def test_aggregate_ucr_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
aggregate_table_definition = AggregateTableDefinition.objects.create(
domain=domain_name,
primary_data_source_id=uuid.uuid4(),
table_id=uuid.uuid4().hex,
)
secondary_table_definition = SecondaryTableDefinition.objects.create(
table_definition=aggregate_table_definition,
data_source_id=uuid.uuid4(),
)
PrimaryColumn.objects.create(
table_definition=aggregate_table_definition)
SecondaryColumn.objects.create(
table_definition=secondary_table_definition)
self._assert_aggregate_ucr_count(domain_name, 1)
self.domain.delete()
self._assert_aggregate_ucr_count(self.domain.name, 0)
self._assert_aggregate_ucr_count(self.domain2.name, 1)
self.assertEqual(SecondaryTableDefinition.objects.count(), 1)
self.assertEqual(
SecondaryTableDefinition.objects.filter(
table_definition__domain=self.domain2.name).count(), 1)
self.assertEqual(PrimaryColumn.objects.count(), 1)
self.assertEqual(
PrimaryColumn.objects.filter(
table_definition__domain=self.domain2.name).count(), 1)
self.assertEqual(SecondaryColumn.objects.count(), 1)
self.assertEqual(
SecondaryColumn.objects.filter(
table_definition__table_definition__domain=self.domain2.name).
count(), 1)
def _assert_case_importer_counts(self, domain_name, count):
self._assert_queryset_count([
CaseUploadFormRecord.objects.filter(
case_upload_record__domain=domain_name),
CaseUploadRecord.objects.filter(domain=domain_name),
], count)
def test_case_importer(self):
for domain_name in [self.domain.name, self.domain2.name]:
case_upload_record = CaseUploadRecord.objects.create(
domain=domain_name,
task_id=uuid.uuid4().hex,
upload_id=uuid.uuid4().hex,
)
CaseUploadFormRecord.objects.create(
case_upload_record=case_upload_record,
form_id=uuid.uuid4().hex,
)
self._assert_case_importer_counts(domain_name, 1)
self.domain.delete()
self._assert_case_importer_counts(self.domain.name, 0)
self._assert_case_importer_counts(self.domain2.name, 1)
self.assertEqual(CaseUploadFormRecord.objects.count(), 1)
self.assertEqual(
CaseUploadFormRecord.objects.filter(
case_upload_record__domain=self.domain2.name).count(), 1)
def _assert_app_manager_counts(self, domain_name, count):
self._assert_queryset_count([
AppReleaseByLocation.objects.filter(domain=domain_name),
LatestEnabledBuildProfiles.objects.filter(domain=domain_name),
GlobalAppConfig.objects.filter(domain=domain_name),
ResourceOverride.objects.filter(domain=domain_name),
], count)
def test_app_manager(self):
for domain_name in [self.domain.name, self.domain2.name]:
location = make_location(domain=domain_name,
site_code='testcode',
name='test',
location_type='facility')
location.save()
AppReleaseByLocation.objects.create(domain=domain_name,
app_id='123',
build_id='456',
version=23,
location=location)
with patch(
'corehq.apps.app_manager.models.GlobalAppConfig.by_app_id'
):
LatestEnabledBuildProfiles.objects.create(domain=domain_name,
app_id='123',
build_id='456',
version=10)
GlobalAppConfig.objects.create(domain=domain_name, app_id='123')
ResourceOverride.objects.create(domain=domain_name,
app_id='123',
root_name='test',
pre_id='456',
post_id='789')
self._assert_app_manager_counts(domain_name, 1)
self.domain.delete()
self._assert_app_manager_counts(self.domain.name, 0)
self._assert_app_manager_counts(self.domain2.name, 1)
location.delete()
def _assert_case_search_counts(self, domain_name, count):
self._assert_queryset_count([
CaseSearchConfig.objects.filter(domain=domain_name),
FuzzyProperties.objects.filter(domain=domain_name),
IgnorePatterns.objects.filter(domain=domain_name),
], count)
def test_case_search(self):
for domain_name in [self.domain.name, self.domain2.name]:
CaseSearchConfig.objects.create(domain=domain_name)
FuzzyProperties.objects.create(domain=domain_name)
IgnorePatterns.objects.create(domain=domain_name)
self._assert_case_search_counts(domain_name, 1)
self.domain.delete()
self._assert_case_search_counts(self.domain.name, 0)
self._assert_case_search_counts(self.domain2.name, 1)
def _assert_cloudcare_counts(self, domain_name, count):
self._assert_queryset_count([
ApplicationAccess.objects.filter(domain=domain_name),
], count)
def test_cloudcare(self):
for domain_name in [self.domain.name, self.domain2.name]:
get_application_access_for_domain(domain_name)
self.domain.delete()
self._assert_cloudcare_counts(self.domain.name, 0)
self._assert_cloudcare_counts(self.domain2.name, 1)
def _assert_consumption_counts(self, domain_name, count):
self._assert_queryset_count([
DefaultConsumption.objects.filter(domain=domain_name),
], count)
def test_consumption(self):
for domain_name in [self.domain.name, self.domain2.name]:
DefaultConsumption.objects.create(domain=domain_name)
self.domain.delete()
self._assert_consumption_counts(self.domain.name, 0)
self._assert_consumption_counts(self.domain2.name, 1)
def _assert_custom_data_fields_counts(self, domain_name, count):
self._assert_queryset_count([
CustomDataFieldsDefinition.objects.filter(domain=domain_name),
], count)
def test_custom_data_fields(self):
for domain_name in [self.domain.name, self.domain2.name]:
CustomDataFieldsDefinition.get_or_create(domain_name, 'UserFields')
self.domain.delete()
self._assert_custom_data_fields_counts(self.domain.name, 0)
self._assert_custom_data_fields_counts(self.domain2.name, 1)
def _assert_data_analytics_counts(self, domain_name, count):
self._assert_queryset_count([
GIRRow.objects.filter(domain_name=domain_name),
MALTRow.objects.filter(domain_name=domain_name),
], count)
def test_data_analytics(self):
for domain_name in [self.domain.name, self.domain2.name]:
GIRRow.objects.create(
domain_name=domain_name,
month=date.today(),
start_date=date.today(),
wams_current=1,
active_users=1,
using_and_performing=1,
not_performing=1,
inactive_experienced=1,
inactive_not_experienced=1,
not_experienced=1,
not_performing_not_experienced=1,
active_ever=1,
possibly_exp=1,
ever_exp=1,
exp_and_active_ever=1,
active_in_span=1,
eligible_forms=1,
)
MALTRow.objects.create(
domain_name=domain_name,
month=date.today(),
num_of_forms=1,
)
self._assert_data_analytics_counts(domain_name, 1)
self.domain.delete()
self._assert_data_analytics_counts(self.domain.name, 0)
self._assert_data_analytics_counts(self.domain2.name, 1)
def _assert_data_dictionary_counts(self, domain_name, count):
self._assert_queryset_count([
CaseType.objects.filter(domain=domain_name),
CaseProperty.objects.filter(case_type__domain=domain_name),
CasePropertyAllowedValue.objects.filter(
case_property__case_type__domain=domain_name),
], count)
def test_data_dictionary(self):
for domain_name in [self.domain.name, self.domain2.name]:
case_type = CaseType.objects.create(domain=domain_name,
name='case_type')
prop = CaseProperty.objects.create(case_type=case_type,
name='case_property',
data_type='select')
CasePropertyAllowedValue.objects.create(case_property=prop,
allowed_value="True")
self._assert_data_dictionary_counts(domain_name, 1)
self.domain.delete()
self._assert_data_dictionary_counts(self.domain.name, 0)
self._assert_data_dictionary_counts(self.domain2.name, 1)
def _assert_data_interfaces(self, domain_name, count):
self._assert_queryset_count([
AutomaticUpdateRule.objects.filter(domain=domain_name),
CaseRuleAction.objects.filter(rule__domain=domain_name),
CaseRuleCriteria.objects.filter(rule__domain=domain_name),
CaseRuleSubmission.objects.filter(domain=domain_name),
DomainCaseRuleRun.objects.filter(domain=domain_name),
], count)
def test_data_interfaces(self):
for domain_name in [self.domain.name, self.domain2.name]:
automatic_update_rule = AutomaticUpdateRule.objects.create(
domain=domain_name)
CaseRuleAction.objects.create(rule=automatic_update_rule)
CaseRuleCriteria.objects.create(rule=automatic_update_rule)
CaseRuleSubmission.objects.create(
created_on=datetime.utcnow(),
domain=domain_name,
form_id=uuid.uuid4().hex,
rule=automatic_update_rule,
)
DomainCaseRuleRun.objects.create(domain=domain_name,
started_on=datetime.utcnow())
self._assert_data_interfaces(domain_name, 1)
self.domain.delete()
self._assert_data_interfaces(self.domain.name, 0)
self._assert_data_interfaces(self.domain2.name, 1)
self.assertEqual(CaseRuleAction.objects.count(), 1)
self.assertEqual(
CaseRuleAction.objects.filter(
rule__domain=self.domain2.name).count(), 1)
self.assertEqual(CaseRuleCriteria.objects.count(), 1)
self.assertEqual(
CaseRuleCriteria.objects.filter(
rule__domain=self.domain2.name).count(), 1)
def _assert_domain_counts(self, domain_name, count):
self._assert_queryset_count([
TransferDomainRequest.objects.filter(domain=domain_name),
], count)
def test_delete_domain(self):
for domain_name in [self.domain.name, self.domain2.name]:
TransferDomainRequest.objects.create(domain=domain_name,
to_username='******',
from_username='******')
self._assert_domain_counts(domain_name, 1)
self.domain.delete()
self._assert_domain_counts(self.domain.name, 0)
self._assert_domain_counts(self.domain2.name, 1)
def _assert_export_counts(self, domain_name, count):
self._assert_queryset_count([
DataFile.meta_query(domain_name),
EmailExportWhenDoneRequest.objects.filter(domain=domain_name),
], count)
def test_export_delete(self):
blobdb = get_blob_db()
data_files = []
for domain_name in [self.domain.name, self.domain2.name]:
data_files.append(
DataFile.save_blob(
BytesIO((domain_name + " csv").encode('utf-8')),
domain=domain_name,
filename="data.csv",
description="data file",
content_type="text/csv",
delete_after=datetime.utcnow() + timedelta(minutes=10),
))
EmailExportWhenDoneRequest.objects.create(domain=domain_name)
self._assert_export_counts(domain_name, 1)
self.domain.delete()
with self.assertRaises(NotFound):
blobdb.get(key=data_files[0].blob_id, type_code=CODES.data_file)
with blobdb.get(key=data_files[1].blob_id,
type_code=CODES.data_file) as f:
self.assertEqual(f.read(),
(self.domain2.name + " csv").encode('utf-8'))
self._assert_export_counts(self.domain.name, 0)
self._assert_export_counts(self.domain2.name, 1)
def _assert_location_counts(self, domain_name, count):
self._assert_queryset_count(
[LocationFixtureConfiguration.objects.filter(domain=domain_name)],
count)
def test_location_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
LocationFixtureConfiguration.objects.create(domain=domain_name)
self._assert_location_counts(domain_name, 1)
self.domain.delete()
self._assert_location_counts(self.domain.name, 0)
self._assert_location_counts(self.domain2.name, 1)
def _assert_ota_counts(self, domain_name, count):
self._assert_queryset_count([
MobileRecoveryMeasure.objects.filter(domain=domain_name),
SerialIdBucket.objects.filter(domain=domain_name),
], count)
def test_ota_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
MobileRecoveryMeasure.objects.create(domain=domain_name)
SerialIdBucket.objects.create(domain=domain_name)
self._assert_ota_counts(domain_name, 1)
self.domain.delete()
self._assert_ota_counts(self.domain.name, 0)
self._assert_ota_counts(self.domain2.name, 1)
def _assert_reports_counts(self, domain_name, count):
self._assert_queryset_count([
ReportsSidebarOrdering.objects.filter(domain=domain_name),
TableauServer.objects.filter(domain=domain_name),
TableauVisualization.objects.filter(domain=domain_name),
], count)
def test_reports_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
ReportsSidebarOrdering.objects.create(domain=domain_name)
server = TableauServer.objects.create(
domain=domain_name,
server_type='server',
server_name='my_server',
target_site='my_site',
domain_username='******',
)
TableauVisualization.objects.create(
domain=domain_name,
server=server,
view_url='my_url',
)
self._assert_reports_counts(domain_name, 1)
self.domain.delete()
self._assert_reports_counts(self.domain.name, 0)
self._assert_reports_counts(self.domain2.name, 1)
def _assert_phone_counts(self, domain_name, count):
self._assert_queryset_count(
[SyncLogSQL.objects.filter(domain=domain_name)], count)
def test_phone_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
SyncLogSQL.objects.create(
domain=domain_name,
doc={},
synclog_id=uuid.uuid4(),
user_id=uuid.uuid4(),
)
self._assert_phone_counts(domain_name, 1)
self.domain.delete()
self._assert_phone_counts(self.domain.name, 0)
self._assert_phone_counts(self.domain2.name, 1)
def _assert_registration_count(self, domain_name, count):
self._assert_queryset_count([
RegistrationRequest.objects.filter(domain=domain_name),
], count)
def test_registration_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
RegistrationRequest.objects.create(
domain=domain_name,
activation_guid=uuid.uuid4().hex,
request_time=datetime.utcnow(),
request_ip='12.34.567.8')
self._assert_registration_count(domain_name, 1)
self.domain.delete()
self._assert_registration_count(self.domain.name, 0)
self._assert_registration_count(self.domain2.name, 1)
def _assert_reminders_counts(self, domain_name, count):
self._assert_queryset_count([
EmailUsage.objects.filter(domain=domain_name),
], count)
def test_reminders_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
EmailUsage.objects.create(domain=domain_name, month=7, year=2018)
self._assert_reminders_counts(domain_name, 1)
self.domain.delete()
self._assert_reminders_counts(self.domain.name, 0)
self._assert_reminders_counts(self.domain2.name, 1)
def _assert_sms_counts(self, domain_name, count):
self._assert_queryset_count([
DailyOutboundSMSLimitReached.objects.filter(domain=domain_name),
Keyword.objects.filter(domain=domain_name),
KeywordAction.objects.filter(keyword__domain=domain_name),
QueuedSMS.objects.filter(domain=domain_name)
], count)
def test_sms_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
DailyOutboundSMSLimitReached.objects.create(domain=domain_name,
date=date.today())
keyword = Keyword.objects.create(domain=domain_name)
KeywordAction.objects.create(keyword=keyword)
QueuedSMS.objects.create(domain=domain_name)
self._assert_sms_counts(domain_name, 1)
self.domain.delete()
self._assert_sms_counts(self.domain.name, 0)
self._assert_sms_counts(self.domain2.name, 1)
self.assertEqual(KeywordAction.objects.count(), 1)
self.assertEqual(
KeywordAction.objects.filter(
keyword__domain=self.domain2.name).count(), 1)
def _assert_smsforms_counts(self, domain_name, count):
self._assert_queryset_count([
SQLXFormsSession.objects.filter(domain=domain_name),
], count)
def test_smsforms_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
SQLXFormsSession.objects.create(
domain=domain_name,
start_time=datetime.utcnow(),
modified_time=datetime.utcnow(),
current_action_due=datetime.utcnow(),
expire_after=3,
)
self._assert_smsforms_counts(domain_name, 1)
self.domain.delete()
self._assert_smsforms_counts(self.domain.name, 0)
self._assert_smsforms_counts(self.domain2.name, 1)
def _assert_translations_count(self, domain_name, count):
self._assert_queryset_count([
SMSTranslations.objects.filter(domain=domain_name),
TransifexBlacklist.objects.filter(domain=domain_name),
], count)
def test_translations_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
SMSTranslations.objects.create(domain=domain_name,
langs=['en'],
translations={'a': 'a'})
TransifexBlacklist.objects.create(domain=domain_name,
app_id='123',
field_name='xyz')
self._assert_translations_count(domain_name, 1)
self.domain.delete()
self._assert_translations_count(self.domain.name, 0)
self._assert_translations_count(self.domain2.name, 1)
def _assert_userreports_counts(self, domain_name, count):
self._assert_queryset_count(
[AsyncIndicator.objects.filter(domain=domain_name)], count)
def test_userreports_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
AsyncIndicator.objects.create(
domain=domain_name,
doc_id=uuid.uuid4().hex,
doc_type='doc_type',
indicator_config_ids=[],
)
self._assert_userreports_counts(domain_name, 1)
self.domain.delete()
self._assert_userreports_counts(self.domain.name, 0)
self._assert_userreports_counts(self.domain2.name, 1)
def _assert_users_counts(self, domain_name, count):
self._assert_queryset_count([
DomainRequest.objects.filter(domain=domain_name),
Invitation.objects.filter(domain=domain_name),
User.objects.filter(
username__contains=f'{domain_name}.{HQ_ACCOUNT_ROOT}')
], count)
def test_users_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
DomainRequest.objects.create(domain=domain_name,
email='*****@*****.**',
full_name='User')
Invitation.objects.create(domain=domain_name,
email='*****@*****.**',
invited_by='*****@*****.**',
invited_on=datetime.utcnow())
User.objects.create(
username=f'mobileuser@{domain_name}.{HQ_ACCOUNT_ROOT}')
self._assert_users_counts(domain_name, 1)
self.domain.delete()
self._assert_users_counts(self.domain.name, 0)
self._assert_users_counts(self.domain2.name, 1)
def test_users_domain_membership(self):
web_user = WebUser.create(
self.domain.name,
f'webuser@{self.domain.name}.{HQ_ACCOUNT_ROOT}',
'******',
created_by=None,
created_via=None)
another_domain = Domain(name="another-test", is_active=True)
another_domain.save()
self.addCleanup(another_domain.delete)
# add more than 1 domain membership to trigger _log_web_user_membership_removed in tests
web_user.add_domain_membership(another_domain.name)
web_user.save()
self.domain.delete()
user_history = UserHistory.objects.last()
self.assertEqual(user_history.by_domain, None)
self.assertEqual(user_history.for_domain, self.domain.name)
self.assertEqual(user_history.changed_by, SYSTEM_USER_ID)
self.assertEqual(user_history.user_id, web_user.get_id)
self.assertEqual(user_history.change_messages,
UserChangeMessage.domain_removal(self.domain.name))
self.assertEqual(
user_history.changed_via,
'corehq.apps.domain.deletion._delete_web_user_membership')
self.assertEqual(user_history.changes, {})
def _assert_role_counts(self, domain_name, roles, permissions,
assignments):
self.assertEqual(
UserRole.objects.filter(domain=domain_name).count(), roles)
self.assertEqual(
RolePermission.objects.filter(role__domain=domain_name).count(),
permissions)
self.assertEqual(
RoleAssignableBy.objects.filter(role__domain=domain_name).count(),
assignments)
def test_roles_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
role1 = UserRole.objects.create(domain=domain_name, name="role1")
role = UserRole.objects.create(domain=domain_name, name="role2")
role.set_permissions([
PermissionInfo(Permissions.view_reports.name,
allow=PermissionInfo.ALLOW_ALL)
])
role.set_assignable_by([role1.id])
self._assert_role_counts(domain_name, 2, 1, 1)
self.domain.delete()
self._assert_role_counts(self.domain.name, 0, 0, 0)
self._assert_role_counts(self.domain2.name, 2, 1, 1)
def _assert_zapier_counts(self, domain_name, count):
self._assert_queryset_count([
ZapierSubscription.objects.filter(domain=domain_name),
], count)
def test_zapier_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
ZapierSubscription.objects.create(
domain=domain_name,
case_type='case_type',
event_name=EventTypes.NEW_CASE,
url='http://%s.com' % domain_name,
user_id='user_id',
)
self._assert_zapier_counts(domain_name, 1)
self.domain.delete()
self._assert_zapier_counts(self.domain.name, 0)
self._assert_zapier_counts(self.domain2.name, 1)
def _assert_motech_count(self, domain_name, count):
self._assert_queryset_count([
RequestLog.objects.filter(domain=domain_name),
], count)
def test_motech_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
RequestLog.objects.create(domain=domain_name)
self._assert_motech_count(domain_name, 1)
self.domain.delete()
self._assert_motech_count(self.domain.name, 0)
self._assert_motech_count(self.domain2.name, 1)
def _assert_repeaters_count(self, domain_name, count):
self._assert_queryset_count([
SQLRepeater.objects.filter(domain=domain_name),
SQLRepeatRecord.objects.filter(domain=domain_name),
SQLRepeatRecordAttempt.objects.filter(
repeat_record__domain=domain_name),
], count)
# Repeater.get_class_from_doc_type is patched because while syncing the
# SQL object to couch, the Repeater.save was erroring while clearing cache
@patch.object(Repeater, 'get_class_from_doc_type')
def test_repeaters_delete(self, mock):
mock.return_value = Repeater
for domain_name in [self.domain.name, self.domain2.name]:
conn = ConnectionSettings.objects.create(
domain=domain_name,
name='To Be Deleted',
url="http://localhost/api/")
repeater = SQLCaseRepeater.objects.create(domain=domain_name,
connection_settings=conn)
record = repeater.repeat_records.create(
domain=domain_name,
registered_at=datetime.utcnow(),
)
record.sqlrepeatrecordattempt_set.create(
state=RECORD_SUCCESS_STATE, )
self._assert_repeaters_count(domain_name, 1)
self.addCleanup(repeater.delete)
self.domain.delete()
self._assert_repeaters_count(self.domain.name, 0)
self._assert_repeaters_count(self.domain2.name, 1)
def _assert_couchforms_counts(self, domain_name, count):
self._assert_queryset_count(
[UnfinishedSubmissionStub.objects.filter(domain=domain_name)],
count)
def test_couchforms_delete(self):
for domain_name in [self.domain.name, self.domain2.name]:
UnfinishedSubmissionStub.objects.create(
domain=domain_name,
timestamp=datetime.utcnow(),
xform_id='xform_id',
)
self._assert_couchforms_counts(domain_name, 1)
self.domain.delete()
self._assert_couchforms_counts(self.domain.name, 0)
self._assert_couchforms_counts(self.domain2.name, 1)
def test_delete_commtrack_config(self):
# Config will have been created by convert_to_commtrack in setUp
self.assertIsNotNone(CommtrackConfig.for_domain(self.domain.name))
self.domain.delete()
self.assertIsNone(CommtrackConfig.for_domain(self.domain.name))
class TestDeleteDomain(TestCase):
def _create_data(self, domain_name, i):
product = Product(domain=domain_name, name='test-{}'.format(i))
product.save()
location = Location(
domain=domain_name,
site_code='testcode-{}'.format(i),
name='test-{}'.format(i),
location_type='facility'
)
location.save()
report = StockReport.objects.create(
type='balance',
domain=domain_name,
form_id='fake',
date=datetime.utcnow()
)
StockTransaction.objects.create(
report=report,
product_id=product.get_id,
sql_product=SQLProduct.objects.get(product_id=product.get_id),
section_id='stock',
type='stockonhand',
case_id=location.linked_supply_point().get_id,
stock_on_hand=100
)
def setUp(self):
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain.convert_to_commtrack()
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.domain2.convert_to_commtrack()
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
LocationType.objects.create(
domain='test',
name='facility2',
)
LocationType.objects.create(
domain='test2',
name='facility2',
)
for i in xrange(2):
self._create_data('test', i)
self._create_data('test2', i)
def _assert_sql_counts(self, domain, number):
self.assertEqual(StockTransaction.objects.filter(report__domain=domain).count(), number)
self.assertEqual(StockReport.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLLocation.objects.filter(domain=domain).count(), number)
self.assertEqual(SQLProduct.objects.filter(domain=domain).count(), number)
self.assertEqual(DocDomainMapping.objects.filter(domain_name=domain).count(), number)
self.assertEqual(LocationType.objects.filter(domain=domain).count(), number)
def test_sql_objects_deletion(self):
self._assert_sql_counts('test', 2)
self.domain.delete()
self._assert_sql_counts('test', 0)
self._assert_sql_counts('test2', 2)
def tearDown(self):
self.domain2.delete()
def request_new_domain(request, form, org, domain_type=None, new_user=True):
now = datetime.utcnow()
current_user = CouchUser.from_django_user(request.user)
dom_req = RegistrationRequest()
if new_user:
dom_req.request_time = now
dom_req.request_ip = get_ip(request)
dom_req.activation_guid = uuid.uuid1().hex
name = form.cleaned_data['hr_name']
with CriticalSection(['request_domain_name_{}'.format(name)]):
name = Domain.generate_name(name)
new_domain = Domain(
name=name,
hr_name=form.cleaned_data['hr_name'],
is_active=False,
date_created=datetime.utcnow(),
creating_user=current_user.username,
secure_submissions=True,
)
if form.cleaned_data.get('domain_timezone'):
new_domain.default_timezone = form.cleaned_data['domain_timezone']
if org:
new_domain.organization = org
new_domain.hr_name = request.POST.get('domain_hrname',
None) or new_domain.name
if not new_user:
new_domain.is_active = True
# ensure no duplicate domain documents get created on cloudant
new_domain.save(**get_safe_write_kwargs())
if domain_type == 'commtrack':
new_domain.convert_to_commtrack()
if not new_domain.name:
new_domain.name = new_domain._id
new_domain.save() # we need to get the name from the _id
create_30_day_trial(new_domain)
dom_req.domain = new_domain.name
if request.user.is_authenticated():
if not current_user:
current_user = WebUser()
current_user.sync_from_django_user(request.user)
current_user.save()
current_user.add_domain_membership(new_domain.name, is_admin=True)
current_user.save()
dom_req.requesting_user_username = request.user.username
dom_req.new_user_username = request.user.username
if new_user:
dom_req.save()
send_domain_registration_email(request.user.email, dom_req.domain,
dom_req.activation_guid)
else:
send_global_domain_registration_email(request.user, new_domain.name)
send_new_request_update_email(request.user,
get_ip(request),
new_domain.name,
is_new_user=new_user)
return new_domain.name
class TestDeleteDomain(TestCase):
def _create_data(self, domain_name, i):
product = Product(domain=domain_name, name='test-{}'.format(i))
product.save()
location = make_location(domain=domain_name,
site_code='testcode-{}'.format(i),
name='test-{}'.format(i),
location_type='facility')
location.save()
report = StockReport.objects.create(
type='balance',
domain=domain_name,
form_id='fake',
date=datetime.utcnow(),
server_date=datetime.utcnow(),
)
StockTransaction.objects.create(
report=report,
product_id=product.get_id,
sql_product=SQLProduct.objects.get(product_id=product.get_id),
section_id='stock',
type='stockonhand',
case_id=location.linked_supply_point().get_id,
stock_on_hand=100)
SMS.objects.create(domain=domain_name)
Call.objects.create(domain=domain_name)
SQLLastReadMessage.objects.create(domain=domain_name)
ExpectedCallback.objects.create(domain=domain_name)
PhoneNumber.objects.create(domain=domain_name,
is_two_way=False,
pending_verification=False)
event = MessagingEvent.objects.create(
domain=domain_name,
date=datetime.utcnow(),
source=MessagingEvent.SOURCE_REMINDER,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED)
MessagingSubEvent.objects.create(
parent=event,
date=datetime.utcnow(),
recipient_type=MessagingEvent.RECIPIENT_CASE,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED)
SelfRegistrationInvitation.objects.create(
domain=domain_name,
phone_number='999123',
token=uuid.uuid4().hex,
expiration_date=datetime.utcnow().date(),
created_date=datetime.utcnow())
backend = SQLMobileBackend.objects.create(domain=domain_name,
is_global=False)
SQLMobileBackendMapping.objects.create(
domain=domain_name,
backend_type=SQLMobileBackend.SMS,
prefix=str(i),
backend=backend)
MobileBackendInvitation.objects.create(domain=domain_name,
backend=backend)
@classmethod
def setUpClass(cls):
super(TestDeleteDomain, cls).setUpClass()
def setUp(self):
super(TestDeleteDomain, self).setUp()
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain.convert_to_commtrack()
self.current_subscription = Subscription.new_domain_subscription(
BillingAccount.get_or_create_account_by_domain(
self.domain.name, created_by='tests')[0],
self.domain.name,
DefaultProductPlan.get_default_plan_version(
SoftwarePlanEdition.ADVANCED),
date_start=date.today() - relativedelta(days=1),
)
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.domain2.convert_to_commtrack()
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
LocationType.objects.create(
domain='test',
name='facility2',
)
LocationType.objects.create(
domain='test2',
name='facility2',
)
for i in range(2):
self._create_data('test', i)
self._create_data('test2', i)
def _assert_sql_counts(self, domain, number):
self.assertEqual(
StockTransaction.objects.filter(report__domain=domain).count(),
number)
self.assertEqual(
StockReport.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLLocation.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLProduct.objects.filter(domain=domain).count(), number)
self.assertEqual(
DocDomainMapping.objects.filter(domain_name=domain).count(),
number)
self.assertEqual(
LocationType.objects.filter(domain=domain).count(), number)
self.assertEqual(SMS.objects.filter(domain=domain).count(), number)
self.assertEqual(Call.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLLastReadMessage.objects.filter(domain=domain).count(), number)
self.assertEqual(
ExpectedCallback.objects.filter(domain=domain).count(), number)
self.assertEqual(
PhoneNumber.objects.filter(domain=domain).count(), number)
self.assertEqual(
MessagingEvent.objects.filter(domain=domain).count(), number)
self.assertEqual(
MessagingSubEvent.objects.filter(parent__domain=domain).count(),
number)
self.assertEqual(
SelfRegistrationInvitation.objects.filter(domain=domain).count(),
number)
self.assertEqual(
SQLMobileBackend.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLMobileBackendMapping.objects.filter(domain=domain).count(),
number)
self.assertEqual(
MobileBackendInvitation.objects.filter(domain=domain).count(),
number)
def test_sql_objects_deletion(self):
self._assert_sql_counts('test', 2)
self._assert_sql_counts('test2', 2)
self.domain.delete()
self._assert_sql_counts('test', 0)
self._assert_sql_counts('test2', 2)
def test_active_subscription_terminated(self):
self.domain.delete()
terminated_subscription = Subscription.visible_objects.get(
subscriber__domain=self.domain.name)
self.assertFalse(terminated_subscription.is_active)
self.assertIsNotNone(terminated_subscription.date_end)
def test_accounting_future_subscription_suppressed(self):
self.current_subscription.date_end = self.current_subscription.date_start + relativedelta(
days=5)
self.current_subscription.save()
next_subscription = Subscription.new_domain_subscription(
self.current_subscription.account,
self.domain.name,
DefaultProductPlan.get_default_plan_version(
edition=SoftwarePlanEdition.PRO),
date_start=self.current_subscription.date_end,
)
self.domain.delete()
self.assertTrue(
Subscription.visible_and_suppressed_objects.get(
id=next_subscription.id).is_hidden_to_ops)
def test_active_subscription_credits_transferred_to_account(self):
credit_amount = random.randint(1, 10)
CreditLine.add_credit(
credit_amount,
feature_type=FeatureType.SMS,
subscription=self.current_subscription,
)
self.domain.delete()
subscription_credits = CreditLine.get_credits_by_subscription_and_features(
self.current_subscription,
feature_type=FeatureType.SMS,
)
self.assertEqual(len(subscription_credits), 1)
self.assertEqual(subscription_credits[0].balance, Decimal('0.0000'))
account_credits = CreditLine.get_credits_for_account(
self.current_subscription.account,
feature_type=FeatureType.SMS,
)
self.assertEqual(len(account_credits), 1)
self.assertEqual(account_credits[0].balance, Decimal(credit_amount))
@patch(
'corehq.apps.accounting.models.DomainDowngradeActionHandler.get_response'
)
def test_downgraded(self, mock_get_response):
mock_get_response.return_value = True
self.domain.delete()
self.assertEqual(len(mock_get_response.call_args_list), 1)
def tearDown(self):
self.domain2.delete()
super(TestDeleteDomain, self).tearDown()
class TestDeleteDomain(TestCase):
def _create_data(self, domain_name, i):
product = Product(domain=domain_name, name='test-{}'.format(i))
product.save()
location = Location(domain=domain_name,
site_code='testcode-{}'.format(i),
name='test-{}'.format(i),
location_type='facility')
location.save()
report = StockReport.objects.create(
type='balance',
domain=domain_name,
form_id='fake',
date=datetime.utcnow(),
server_date=datetime.utcnow(),
)
StockTransaction.objects.create(
report=report,
product_id=product.get_id,
sql_product=SQLProduct.objects.get(product_id=product.get_id),
section_id='stock',
type='stockonhand',
case_id=location.linked_supply_point().get_id,
stock_on_hand=100)
SMS.objects.create(domain=domain_name)
Call.objects.create(domain=domain_name)
SQLLastReadMessage.objects.create(domain=domain_name)
ExpectedCallback.objects.create(domain=domain_name)
PhoneNumber.objects.create(domain=domain_name)
event = MessagingEvent.objects.create(
domain=domain_name,
date=datetime.utcnow(),
source=MessagingEvent.SOURCE_REMINDER,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED)
MessagingSubEvent.objects.create(
parent=event,
date=datetime.utcnow(),
recipient_type=MessagingEvent.RECIPIENT_CASE,
content_type=MessagingEvent.CONTENT_SMS,
status=MessagingEvent.STATUS_COMPLETED)
SelfRegistrationInvitation.objects.create(
domain=domain_name,
phone_number='999123',
token=uuid.uuid4().hex,
expiration_date=datetime.utcnow().date(),
created_date=datetime.utcnow())
backend = SQLMobileBackend.objects.create(domain=domain_name,
is_global=False)
SQLMobileBackendMapping.objects.create(
domain=domain_name,
backend_type=SQLMobileBackend.SMS,
prefix=str(i),
backend=backend)
MobileBackendInvitation.objects.create(domain=domain_name,
backend=backend)
def setUp(self):
self.domain = Domain(name="test", is_active=True)
self.domain.save()
self.domain.convert_to_commtrack()
self.domain2 = Domain(name="test2", is_active=True)
self.domain2.save()
self.domain2.convert_to_commtrack()
LocationType.objects.create(
domain='test',
name='facility',
)
LocationType.objects.create(
domain='test2',
name='facility',
)
LocationType.objects.create(
domain='test',
name='facility2',
)
LocationType.objects.create(
domain='test2',
name='facility2',
)
for i in xrange(2):
self._create_data('test', i)
self._create_data('test2', i)
def _assert_sql_counts(self, domain, number):
self.assertEqual(
StockTransaction.objects.filter(report__domain=domain).count(),
number)
self.assertEqual(
StockReport.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLLocation.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLProduct.objects.filter(domain=domain).count(), number)
self.assertEqual(
DocDomainMapping.objects.filter(domain_name=domain).count(),
number)
self.assertEqual(
LocationType.objects.filter(domain=domain).count(), number)
self.assertEqual(SMS.objects.filter(domain=domain).count(), number)
self.assertEqual(Call.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLLastReadMessage.objects.filter(domain=domain).count(), number)
self.assertEqual(
ExpectedCallback.objects.filter(domain=domain).count(), number)
self.assertEqual(
PhoneNumber.objects.filter(domain=domain).count(), number)
self.assertEqual(
MessagingEvent.objects.filter(domain=domain).count(), number)
self.assertEqual(
MessagingSubEvent.objects.filter(parent__domain=domain).count(),
number)
self.assertEqual(
SelfRegistrationInvitation.objects.filter(domain=domain).count(),
number)
self.assertEqual(
SQLMobileBackend.objects.filter(domain=domain).count(), number)
self.assertEqual(
SQLMobileBackendMapping.objects.filter(domain=domain).count(),
number)
self.assertEqual(
MobileBackendInvitation.objects.filter(domain=domain).count(),
number)
def test_sql_objects_deletion(self):
self._assert_sql_counts('test', 2)
self._assert_sql_counts('test2', 2)
self.domain.delete()
self._assert_sql_counts('test', 0)
self._assert_sql_counts('test2', 2)
def tearDown(self):
self.domain2.delete()
