def setUp(self):
self.username = '******'
self.paid_user, _ = User.objects.get_or_create(username=self.username,email=self.username,password='******')
self.paid_user.save()
self.paid_org = Organization(name='test_org_for_correct_active_date', sector='PublicHealth', address='add', city='city', country=Country('MG'),
zipcode='10000', active_date=None)
self.paid_org.save()
self.mobile_number = "1233"
self.paid_user_profile = NGOUserProfile(user=self.paid_user, title='Mr.', org_id=self.paid_org.org_id,mobile_phone=self.mobile_number)
self.paid_user_profile.save()
self.trial_username = '******'
self.trial_user, _ = User.objects.get_or_create(username=self.trial_username,email=self.trial_username,password='******')
self.trial_user.save()
self.trial_org = Organization(name='trial_org', sector='PublicHealth', address='add', city='city', country=Country('MG'),
zipcode='10000', active_date=None, in_trial_mode=True,org_id='test')
self.trial_org.save()
self.trial_mobile_number = "12445"
self.trial_user_profile = NGOUserProfile(user=self.trial_user, title='Mr.', org_id=self.trial_org.org_id,mobile_phone=self.trial_mobile_number)
self.trial_user_profile.save()
self.patcher1 = patch('datawinners.accountmanagement.post_activation_events.get_entity_count_for_type')
self.get_all_entities_mock = self.patcher1.start()
self.patcher2 = patch('datawinners.accountmanagement.post_activation_events.create_entity')
self.create_entity_mock = self.patcher2.start()
self.patcher3 = patch('datawinners.accountmanagement.post_activation_events.get_or_create_data_dict')
self.get_or_create_data_dict_mock = self.patcher3.start()
def test_get_active_paid_org_should_not_return_deactivate_org(self):
ORG_DETAILS = {
'organization_name': 'myCompany',
'organization_sector': 'Public Health',
'organization_city': 'xian',
'organization_country': 'china',
'organization_address': 'myAddress',
'organization_addressline2': 'myAddressL2',
'organization_state': "MyState",
'organization_zipcode': "1234565",
'organization_office_phone': "123113123",
'organization_website': "*****@*****.**",
'language': "en"
}
deactivated_organization = Organization.create_organization(
ORG_DETAILS)
deactivated_organization.status = "Deactivated"
deactivated_organization.save()
activated_organization = Organization.create_organization(ORG_DETAILS)
activated_organization.status = 'Activated'
activated_organization.save()
organizations = _get_active_paid_organization()
self.assertNotIn(deactivated_organization, organizations)
self.assertIn(activated_organization, organizations)
activated_organization.delete()
deactivated_organization.delete()
def _prepare_organization(self):
trial_organization = Organization(
name='test_org_for_trial_account',
sector='PublicHealth',
address='add',
city='Pune',
country='IN',
zipcode='411006',
account_type='Basic',
org_id=OrganizationIdCreator().generateId(),
status='Activated')
trial_organization.save()
today = datetime.datetime.today()
mt_current_month = MessageTracker(month=datetime.date(
today.year, today.month, 12),
incoming_web_count=7,
incoming_sms_count=13,
incoming_sp_count=5,
sms_api_usage_count=3,
sms_api_usage_charged_count=3,
sms_registration_count=2,
sent_reminders_count=10,
sent_reminders_charged_count=10,
send_message_count=0,
send_message_charged_count=0,
outgoing_sms_count=40,
outgoing_sms_charged_count=40,
organization=trial_organization)
mt_current_month.save()
mt_current_month = MessageTracker(month=datetime.date(
today.year, today.month, 1),
incoming_web_count=3,
incoming_sms_count=20,
incoming_sp_count=10,
sms_api_usage_count=3,
sms_registration_count=4,
outgoing_sms_count=40,
organization=trial_organization)
mt_current_month.save()
year = today.year
month = today.month
if today.month == 1:
year -= 1
month = 12
mt_last_month = MessageTracker(month=datetime.date(year, month, 1),
incoming_web_count=10,
incoming_sms_count=10,
incoming_sp_count=7,
sms_api_usage_count=3,
sms_registration_count=4,
outgoing_sms_count=40,
organization=trial_organization)
mt_last_month.save()
return trial_organization
def _prepare_organization(self):
trial_organization = Organization(
name='test_org_for_trial_account',
sector='PublicHealth',
address='add',
city='Pune',
country='IN',
zipcode='411006',
in_trial_mode=True,
org_id=OrganizationIdCreator().generateId())
trial_organization.save()
return trial_organization
def create_organization(self, active_date=None):
organization = Organization(
name='twu',
sector='Gaoxin',
address='xian',
city='Xian',
state='ShanXi',
country='CHN',
zipcode='730000',
office_phone='12345678911',
website='http://google.com',
active_date=active_date,
org_id=OrganizationIdCreator().generateId())
organization.in_trial_mode = True
return organization
def test_user_email_validation_should_be_case_insensitive(self):
User.objects.create_user('*****@*****.**', '*****@*****.**', 'password')
trial_organization = Organization(
name='test_org_for_trial_account',
sector='PublicHealth',
address='add',
city='Pune',
country='IN',
zipcode='411006',
account_type='Basic',
org_id=OrganizationIdCreator().generateId(),
status='Activated')
trial_organization.save()
mobile_validater = MobileNumberValidater(trial_organization, '788522',
'no_id')
mobile_validater.validate = MagicMock(return_value=(True, ''))
with patch("datawinners.accountmanagement.forms.MobileNumberValidater"
) as validater:
with patch(
"datawinners.accountmanagement.forms.datasender_count_with"
) as datasender_count_with_mock:
validater.return_value = mobile_validater
form = UserProfileForm(organization=trial_organization,
data={
'title': 'manager',
'full_name': 'user one',
'username': '******',
'mobile_phone': '7889522'
})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['username'], [
'This email address is already in use. Please supply a different email address'
])
mobile_validater.validate.assert_called_with()
datasender_count_with_mock.return_value = 0
form = UserProfileForm(organization=trial_organization,
data={
'title': 'manager',
'full_name': 'user one',
'username': '******',
'mobile_phone': '7889522'
})
self.assertTrue(form.is_valid())
self.assertEqual(form.clean_username(), '*****@*****.**')
def create_organization(self):
organization = Organization('organization_name',
'organization_sector',
'organization_address',
'organization_city',
'organization_state',
'organization_country',
'organization_zipcode',
'organization_office_phone',
'organization_website',
org_id = self.org_id,
account_type = 'Basic',
active_date = datetime(2011,07,11))
organization.save()
self.organization_setting = OrganizationSetting()
self.organization_setting.organization = organization
self.organization_setting.document_store = slugify("%s_%s_%s" % ("HNI", organization.name, self.org_id))
self.organization_setting.save()
def test_get_paid_org_should_return_only_paid_org(self):
TRIAL_ORGANIZATION_PARAMS = {'organization_name': 'myCompany',
'organization_sector': 'Public Health',
'organization_city': 'xian',
'organization_country': 'china',
}
self.organization = Organization.create_trial_organization(TRIAL_ORGANIZATION_PARAMS)
self.organization.save()
organizations = _get_paid_organization()
self.assertNotIn(self.organization,organizations)
def test_is_pro_sms(self):
pro_sms_organization = Organization(
name='pro_sms_ngo',
sector='Education',
address='Fianar',
city='Mahasoabe',
country='IN',
zipcode='301',
account_type='Pro SMS',
org_id=OrganizationIdCreator().generateId(),
status='Activated')
self.assertEqual(pro_sms_organization.is_pro_sms, True)
self.assertEqual(pro_sms_organization.in_trial_mode, False)
def prepare_organization(self):
self.paid_organization = Organization(
name='test_org_for_paid_account',
sector='PublicHealth',
address='add',
city='Pune',
country='India',
zipcode='411006',
account_type='Pro SMS',
org_id=OrganizationIdCreator().generateId())
self.trial_organization = Organization(
name='test_org_for_trial_account',
sector='PublicHealth',
address='add',
city='Pune',
country='India',
zipcode='411006',
account_type='Basic',
org_id=OrganizationIdCreator().generateId())
self.paid_organization.save()
self.trial_organization.save()
def test_user_email_validation_should_be_case_insensitive(self):
User.objects.create_user('*****@*****.**', '*****@*****.**', 'password')
trial_organization = Organization(
name='test_org_for_trial_account',
sector='PublicHealth',
address='add',
city='Pune',
country='IN',
zipcode='411006',
account_type='Basic',
org_id=OrganizationIdCreator().generateId(),
status='Activated')
trial_organization.save()
form = UserProfileForm(organization=trial_organization,
data={
'title': 'manager',
'full_name': 'user one',
'username': '******',
'mobile_phone': '7889522'
})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors['username'], [
'This email address is already in use. Please supply a different email address'
])
form = UserProfileForm(organization=trial_organization,
data={
'title': 'manager',
'full_name': 'user one',
'username': '******',
'mobile_phone': '7889522'
})
self.assertTrue(form.is_valid())
self.assertEqual(form.clean_username(), '*****@*****.**')
def prepare_organization(self):
self.expired_organization_out_of_one_year = Organization(
name='test_org_for_expired_organization_out_of_one_year',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
account_type='Basic',
active_date=datetime.today() -
relativedelta(years=settings.TRIAL_PERIOD_IN_YEAR, days=1),
org_id=OrganizationIdCreator().generateId())
self.paid_organization = Organization(
name='test_org_for_paid_account',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
account_type='Pro SMS',
active_date=datetime(2011, 8, 15),
org_id=OrganizationIdCreator().generateId())
self.unexpired_organization = Organization(
name='test_org_for_unexpired_account',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
account_type='Basic',
active_date=datetime.today(),
org_id=OrganizationIdCreator().generateId())
self.expired_organization_of_one_year = Organization(
name='test_org_for_expired_organization_of_one_year',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
account_type='Basic',
active_date=datetime.today() -
relativedelta(years=settings.TRIAL_PERIOD_IN_YEAR),
org_id=OrganizationIdCreator().generateId())
self.expired_organization_of_one_year.save()
self.expired_organization_out_of_one_year.save()
self.unexpired_organization.save()
self.paid_organization.save()
def prepare_organization(self):
self.expired_organization_out_of_31_days = Organization(
name='test_org_for_expired_organization_out_of_31_days',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
in_trial_mode=True,
active_date=datetime.today() - timedelta(days=31),
org_id=OrganizationIdCreator().generateId())
self.paid_organization = Organization(
name='test_org_for_paid_account',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
in_trial_mode=False,
active_date=datetime(2011, 8, 15),
org_id=OrganizationIdCreator().generateId())
self.unexpired_organization = Organization(
name='test_org_for_unexpired_account',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
in_trial_mode=True,
active_date=datetime.today(),
org_id=OrganizationIdCreator().generateId())
self.expired_organization_of_30_days = Organization(
name='test_org_for_expired_organization_of_30_days',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
in_trial_mode=True,
active_date=datetime.today() - timedelta(days=30),
org_id=OrganizationIdCreator().generateId())
self.expired_organization_of_30_days.save()
self.expired_organization_out_of_31_days.save()
self.unexpired_organization.save()
self.paid_organization.save()
class TestPostActivationEvents(unittest.TestCase):
def setUp(self):
self.username = '******'
self.paid_user, _ = User.objects.get_or_create(username=self.username,
email=self.username,
password='******')
self.paid_user.save()
self.paid_org = Organization(name='test_org_for_correct_active_date',
sector='PublicHealth',
address='add',
city='city',
country=Country('MG'),
zipcode='10000',
active_date=None)
self.paid_org.save()
self.mobile_number = "1233"
self.paid_user_profile = NGOUserProfile(
user=self.paid_user,
title='Mr.',
org_id=self.paid_org.org_id,
mobile_phone=self.mobile_number)
self.paid_user_profile.save()
self.trial_username = '******'
self.trial_user, _ = User.objects.get_or_create(
username=self.trial_username,
email=self.trial_username,
password='******')
self.trial_user.save()
self.trial_org = Organization(name='trial_org',
sector='PublicHealth',
address='add',
city='city',
country=Country('MG'),
zipcode='10000',
active_date=None,
account_type='Basic',
org_id='test')
self.trial_org.save()
self.trial_mobile_number = "12445"
self.trial_user_profile = NGOUserProfile(
user=self.trial_user,
title='Mr.',
org_id=self.trial_org.org_id,
mobile_phone=self.trial_mobile_number)
self.trial_user_profile.save()
self.patcher1 = patch(
'datawinners.accountmanagement.post_activation_events.get_entity_count_for_type'
)
self.get_all_entities_mock = self.patcher1.start()
self.patcher2 = patch(
'datawinners.accountmanagement.post_activation_events.create_contact'
)
self.create_entity_mock = self.patcher2.start()
def test_active_organization_with_should_active_date_is_none_save_active_date(
self):
active_organization(org=self.paid_org)
self.assertIsNotNone(
Organization.objects.get(org_id=self.paid_org.org_id).active_date)
self.assertEqual(
Organization.objects.get(
org_id=self.paid_org.org_id).active_date.microsecond, 0)
def test_should_make_datasender_entity_for_paid_account(self):
mock_manager = Mock(spec=DatabaseManager)
entity_mock = Mock(spec=Contact)
entity_mock.type_path = [REPORTER]
self.get_all_entities_mock.return_value = 1
self.create_entity_mock = entity_mock
make_user_as_a_datasender(mock_manager, self.paid_org, self.username,
self.mobile_number)
entity_mock.add_data.assert_called_once()
def test_should_make_datasender_entity_and_datasender_on_trial_account_for_trial_account(
self):
mock_manager = Mock(spec=DatabaseManager)
entity_mock = Mock(spec=Entity)
entity_mock.type_path = [REPORTER]
self.get_all_entities_mock.return_value = 1
self.create_entity_mock = entity_mock
make_user_as_a_datasender(mock_manager, self.trial_org,
self.trial_username,
self.trial_mobile_number)
entity_mock.add_data.assert_called_once()
data_senders_on_trial_account = DataSenderOnTrialAccount.objects.filter(
organization=self.trial_org)
self.assertEqual(1, len(data_senders_on_trial_account))
self.assertEqual(self.trial_mobile_number,
data_senders_on_trial_account[0].mobile_number)
self.assertEqual(self.trial_org,
data_senders_on_trial_account[0].organization)
def tearDown(self):
self.paid_user_profile.delete()
self.paid_org.delete()
self.paid_user.delete()
self.trial_user_profile.delete()
self.trial_org.delete()
self.trial_user.delete()
DataSenderOnTrialAccount.objects.filter(
organization=self.trial_org).delete()
self.patcher1.stop()
self.patcher2.stop()
class TestRegistrationProcessor(unittest.TestCase):
def prepare_organization(self):
self.paid_organization = Organization(
name='test_org_for_paid_account',
sector='PublicHealth',
address='add',
city='Pune',
country='India',
zipcode='411006',
account_type='Pro SMS',
org_id=OrganizationIdCreator().generateId())
self.trial_organization = Organization(
name='test_org_for_trial_account',
sector='PublicHealth',
address='add',
city='Pune',
country='India',
zipcode='411006',
account_type='Basic',
org_id=OrganizationIdCreator().generateId())
self.paid_organization.save()
self.trial_organization.save()
def setUp(self):
set_email_settings()
User.objects.filter(username='******').delete()
User.objects.filter(username='******').delete()
Organization.objects.filter(name='test_org_for_paid_account').delete()
Organization.objects.filter(name='test_org_for_trial_account').delete()
self.user1 = RegistrationProfile.objects.create_inactive_user(
username='******',
email='*****@*****.**',
password='******',
site=Site(),
send_email=False)
self.user2 = RegistrationProfile.objects.create_inactive_user(
username='******',
email='*****@*****.**',
password='******',
site=Site(),
send_email=False)
self.user1.first_name = 'first_name1 last_name1'
self.user2.first_name = 'first_name2 last_name2'
self.user1.save()
self.user2.save()
self.prepare_organization()
NGOUserProfile(user=self.user1,
title='Mr.',
org_id=self.paid_organization.org_id).save()
NGOUserProfile(user=self.user2,
title='Ms.',
org_id=self.trial_organization.org_id).save()
self.processor = RegistrationBackend()
def tearDown(self):
self.user1.delete()
self.user2.delete()
self.paid_organization.delete()
self.trial_organization.delete()
def test_should_get_the_correct_registration_processor(self):
self.assertTrue(
isinstance(
self.processor.get_registration_processor(
self.trial_organization),
TrialAccountRegistrationProcessor))
self.assertTrue(
isinstance(
self.processor.get_registration_processor(
self.paid_organization), PaidAccountRegistrationProcessor))
def test_should_process_registration_data_for_paid_acccount_in_english(
self):
with patch.object(ProSMSAccountRegistrationProcessor,
'_get_invoice_total') as get_invoice_total_patch:
get_invoice_total_patch.return_value = PRO_SMS_MONTHLY_PRICING, '1 month'
processor = self.processor.get_registration_processor(
self.paid_organization)
site = Site(domain='test', name='test_site')
kwargs = dict(invoice_period='', preferred_payment='')
processor.process(self.user1, site, 'en', kwargs)
emails = [mail.outbox.pop() for i in range(len(mail.outbox))]
self.assertEqual(1, len(emails))
sent_email = emails[0]
self.assertEqual("html", sent_email.content_subtype)
self.assertEqual(settings.EMAIL_HOST_USER, sent_email.from_email)
self.assertEqual(['*****@*****.**'], sent_email.to)
self.assertEqual([settings.HNI_SUPPORT_EMAIL_ID], sent_email.bcc)
self.assertEqual(
render_to_string(
'registration/activation_email_subject_in_en.txt'),
sent_email.subject)
ctx_dict = {
'activation_key':
RegistrationProfile.objects.get(
user=self.user1).activation_key,
'expiration_days':
settings.ACCOUNT_ACTIVATION_DAYS,
'site':
site,
'username':
self.user1.first_name,
'invoice_total':
PRO_SMS_MONTHLY_PRICING,
'period':
'1 month'
}
self.assertEqual(
render_to_string(
'registration/pro_sms_activation_email_in_en.html',
ctx_dict), sent_email.body)
payment_detail = PaymentDetails.objects.filter(
organization=self.paid_organization)
self.assertTrue(is_not_empty(payment_detail))
payment_detail.delete()
def test_should_process_registration_data_for_trial_acccount_in_english(
self):
processor = self.processor.get_registration_processor(
self.trial_organization)
site = Site(domain='test', name='test_site')
kwargs = dict(invoice_period='', preferred_payment='')
processor.process(self.user2, site, 'en', kwargs)
emails = [mail.outbox.pop() for i in range(len(mail.outbox))]
self.assertEqual(1, len(emails))
sent_email = emails[0]
self.assertEqual("html", sent_email.content_subtype)
self.assertEqual(settings.EMAIL_HOST_USER, sent_email.from_email)
self.assertEqual(['*****@*****.**'], sent_email.to)
self.assertEqual([settings.HNI_SUPPORT_EMAIL_ID], sent_email.bcc)
ctx_dict = {
'activation_key':
RegistrationProfile.objects.get(user=self.user2).activation_key,
'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS,
'site': site,
'username': self.user2.first_name
}
self.assertEqual(
render_to_string(
'registration/activation_email_subject_for_trial_account_in_en.txt'
), sent_email.subject)
self.assertEqual(
render_to_string(
'registration/activation_email_for_trial_account_in_en.html',
ctx_dict), sent_email.body)
def test_should_process_registration_data_for_paid_acccount_in_french(
self):
with patch.object(ProSMSAccountRegistrationProcessor,
'_get_invoice_total') as get_invoice_total_patch:
get_invoice_total_patch.return_value = PRO_SMS_MONTHLY_PRICING, '1 month'
processor = self.processor.get_registration_processor(
self.paid_organization)
site = Site(domain='test', name='test_site')
kwargs = dict(invoice_period='', preferred_payment='')
processor.process(self.user1, site, 'fr', kwargs)
emails = [mail.outbox.pop() for i in range(len(mail.outbox))]
self.assertEqual(1, len(emails))
sent_email = emails[0]
self.assertEqual("html", sent_email.content_subtype)
self.assertEqual(settings.EMAIL_HOST_USER, sent_email.from_email)
self.assertEqual(['*****@*****.**'], sent_email.to)
self.assertEqual([settings.HNI_SUPPORT_EMAIL_ID], sent_email.bcc)
self.assertEqual(
render_to_string(
'registration/activation_email_subject_in_fr.txt'),
sent_email.subject)
ctx_dict = {
'activation_key':
RegistrationProfile.objects.get(
user=self.user1).activation_key,
'expiration_days':
settings.ACCOUNT_ACTIVATION_DAYS,
'site':
site,
'username':
self.user1.first_name,
'invoice_total':
PRO_SMS_MONTHLY_PRICING,
'period':
'1 month'
}
self.assertEqual(
render_to_string(
'registration/pro_sms_activation_email_in_fr.html',
ctx_dict), sent_email.body)
payment_detail = PaymentDetails.objects.filter(
organization=self.paid_organization)
self.assertTrue(is_not_empty(payment_detail))
payment_detail.delete()
def test_should_process_registration_data_for_trial_acccount_in_french(
self):
processor = self.processor.get_registration_processor(
self.trial_organization)
site = Site(domain='test', name='test_site')
kwargs = dict(invoice_period='', preferred_payment='')
processor.process(self.user2, site, 'fr', kwargs)
emails = [mail.outbox.pop() for i in range(len(mail.outbox))]
self.assertEqual(1, len(emails))
sent_email = emails[0]
self.assertEqual("html", sent_email.content_subtype)
self.assertEqual(settings.EMAIL_HOST_USER, sent_email.from_email)
self.assertEqual(['*****@*****.**'], sent_email.to)
self.assertEqual([settings.HNI_SUPPORT_EMAIL_ID], sent_email.bcc)
ctx_dict = {
'activation_key':
RegistrationProfile.objects.get(user=self.user2).activation_key,
'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS,
'site': site,
'username': self.user2.first_name
}
self.assertEqual(
render_to_string(
'registration/activation_email_subject_for_trial_account_in_fr.txt'
), sent_email.subject)
self.assertEqual(
render_to_string(
'registration/activation_email_for_trial_account_in_fr.html',
ctx_dict), sent_email.body)
def test_should_get_only_active_trail_org(self):
self.organization.deactivate()
organizations = Organization.get_all_active_trial_organizations()
self.assertNotIn(self.organization, organizations)
class TestDeactivateExpiredAccount(unittest.TestCase):
def prepare_organization(self):
self.expired_organization_out_of_one_year = Organization(
name='test_org_for_expired_organization_out_of_one_year',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
account_type='Basic',
active_date=datetime.today() -
relativedelta(years=settings.TRIAL_PERIOD_IN_YEAR, days=1),
org_id=OrganizationIdCreator().generateId())
self.paid_organization = Organization(
name='test_org_for_paid_account',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
account_type='Pro SMS',
active_date=datetime(2011, 8, 15),
org_id=OrganizationIdCreator().generateId())
self.unexpired_organization = Organization(
name='test_org_for_unexpired_account',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
account_type='Basic',
active_date=datetime.today(),
org_id=OrganizationIdCreator().generateId())
self.expired_organization_of_one_year = Organization(
name='test_org_for_expired_organization_of_one_year',
sector='PublicHealth',
address='add',
city='xian',
country='china',
zipcode='10000',
account_type='Basic',
active_date=datetime.today() -
relativedelta(years=settings.TRIAL_PERIOD_IN_YEAR),
org_id=OrganizationIdCreator().generateId())
self.expired_organization_of_one_year.save()
self.expired_organization_out_of_one_year.save()
self.unexpired_organization.save()
self.paid_organization.save()
def setUp(self):
try:
User.objects.get(username='******').delete()
User.objects.get(username='******').delete()
Organization.objects.get(
name='test_org_for_expired_organization_out_of_one_years'
).delete()
Organization.objects.get(name='test_org_for_paid_account').delete()
Organization.objects.get(
name='test_org_for_unexpired_account').delete()
Organization.objects.get(
name='test_org_for_expired_organization_of_one_year').delete()
except:
pass
self.user1 = User(username='******',
email='*****@*****.**',
password='******',
first_name='first_name1 last_name1')
self.user2 = User(username='******',
email='*****@*****.**',
password='******',
first_name='first_name2 last_name2')
self.user1.set_password('expired')
self.user2.set_password('expired')
self.user1.save()
self.user2.save()
self.prepare_organization()
NGOUserProfile(
user=self.user1,
title='Mr.',
org_id=self.expired_organization_of_one_year.org_id).save()
NGOUserProfile(
user=self.user2,
title='Ms.',
org_id=self.expired_organization_of_one_year.org_id).save()
def tearDown(self):
self.user1.delete()
self.user2.delete()
self.expired_organization_of_one_year.delete()
self.expired_organization_out_of_one_year.delete()
self.unexpired_organization.delete()
self.paid_organization.delete()
def test_get_organization_creator_should_return_first_user_of_organization(
self):
self.assertEqual(get_creator(self.expired_organization_of_one_year),
self.user1)
def test_should_not_contain_unexpired_organizations(self):
organizations = get_expired_trial_organizations_without_deactivate_email_sent(
)
self.assertIn(self.expired_organization_of_one_year, organizations)
self.assertNotIn(self.unexpired_organization, organizations)
def test_should_not_contain_paid_organizations(self):
organizations = get_expired_trial_organizations_without_deactivate_email_sent(
)
self.assertNotIn(self.paid_organization, organizations)
def test_should_not_contain_organization_active_date_out_of_one_year(self):
organizations = get_expired_trial_organizations_without_deactivate_email_sent(
)
self.assertIn(self.expired_organization_out_of_one_year, organizations)
def test_get_user_list_should_return_organization_creator(self):
creators = get_creators([self.expired_organization_of_one_year])
self.assertIn(self.user1, creators)
def test_create_email_should_get_email_with_html_content(self):
msg1 = create_email(self.user1)
msg2 = create_email(self.user2)
self.assertEqual(msg1.content_subtype, 'html')
self.assertEqual(msg2.content_subtype, 'html')
def test_create_email_should_get_email_with_right_subject(self):
msg1 = create_email(self.user1)
msg2 = create_email(self.user2)
self.assertEqual(msg1.subject, 'Account Expired')
self.assertEqual(msg2.subject, 'Account Expired')
def test_create_email_should_get_email_contain_right_user_name(self):
msg1 = create_email(self.user1)
msg2 = create_email(self.user2)
self.assertIn(self.user1.first_name, msg1.body)
self.assertIn(self.user2.first_name, msg2.body)
def test_create_email_should_get_right_recipient(self):
msg1 = create_email(self.user1)
msg2 = create_email(self.user2)
self.assertIn(self.user1.email, msg1.to)
self.assertIn(self.user2.email, msg2.to)
def test_deactivate_email_sent(self):
settings.EMAIL_BACKEND = 'django.core.mail.backends.filebased.EmailBackend'
settings.EMAIL_FILE_PATH = 'email'
send_deactivate_email()
list = dircache.listdir('email')
emails = ''
for email in list:
emails += open('email/' + email, 'r').read()
os.remove('email/' + email)
self.assertIn('From: ' + settings.EMAIL_HOST_USER, emails)
self.assertIn('To: [email protected]', emails)
self.assertIn('Subject: Account Expired', emails)
self.assertIn('Hello first_name1 last_name1', emails)
self.assertNotIn('To: [email protected]', emails)
def test_deactivate_email_only_sent_once(self):
organisation_list = get_expired_trial_organizations_without_deactivate_email_sent(
)
number_before = len(organisation_list)
self.assertIsNot(0, number_before)
send_deactivate_email()
organisation_list = get_expired_trial_organizations_without_deactivate_email_sent(
)
number_after = len(organisation_list)
self.assertLess(number_after, number_before)
def test_paid_account_not_in_all_expired_account(self):
organizations = get_expired_trial_organizations()
self.assertNotIn(self.paid_organization, organizations)
def test_unexpired_account_not_in_expired_account(self):
organizations = get_expired_trial_organizations()
self.assertNotIn(self.unexpired_organization, organizations)
def test_should_deactivate_related_users_when_deactivating_organization(
self):
organization = self.expired_organization_of_one_year
for user in organization.get_related_users():
self.assertTrue(user.is_active)
organization.deactivate()
for user in organization.get_related_users():
self.assertFalse(user.is_active)
def create_respective_organization(self, kwargs):
if self.is_subscription_registration(kwargs):
organization = Organization.create_organization(kwargs)
else:
organization = Organization.create_trial_organization(kwargs)
return organization
