def test_get_inactive_users_data_added(self):
CommCareUser(domain='icds-cas',
username='******').save()
CommCareUser(domain='icds-cas',
username='******').save()
IcdsFile.objects.filter(
data_type='inactive_dashboard_users').all().delete()
collect_inactive_dashboard_users()
sync = IcdsFile.objects.filter(data_type='inactive_dashboard_users'
).order_by('-file_added').first()
with sync.get_file_from_blobdb() as fileobj, NamedTemporaryFile(
) as out:
shutil.copyfileobj(fileobj, out)
zip = zipfile.ZipFile(out, 'r')
for zipped_file in zip.namelist():
items_file = zip.open(zipped_file)
items_file = io.TextIOWrapper(io.BytesIO(items_file.read()))
csv_reader = csv.reader(items_file)
data = list(csv_reader)
sorted(data, key=lambda x: x[0])
self.assertEqual(['Username', 'Location', 'State'], data[0])
self.assertCountEqual([
['*****@*****.**', '', ''],
['*****@*****.**', '', ''],
], data[1:])
def test_commcare_user_flag(self):
self.assertFalse(WebUser().is_commcare_user())
self.assertFalse(CouchUser.wrap(WebUser().to_json()).is_commcare_user())
self.assertTrue(CommCareUser().is_commcare_user())
self.assertTrue(CouchUser.wrap(CommCareUser().to_json()).is_commcare_user())
with self.assertRaises(NotImplementedError):
CouchUser().is_commcare_user()
def test_get_doc_count_in_domain_by_class(self):
user = CommCareUser(username="******", domain=self.domain)
user.save()
self.addCleanup(user.delete, self.domain, None)
user2 = CommCareUser(username="******", domain=self.domain)
user2.save()
self.addCleanup(user2.delete, self.domain, None)
get = functools.partial(get_doc_count_in_domain_by_class, self.domain,
CommCareUser)
self.assertEqual(get(), 2)
def setUpClass(cls):
super().setUpClass()
cls.user = CommCareUser(
domain=DOMAIN,
username=f'bob@{DOMAIN}.commcarehq.org',
)
cls.user.save()
class TestUserStagingTable(BaseStagingTableTest, StagingRecordsTestsMixin):
slug = 'user_dim'
records = [
# TODO: Make domains compatible with staging table
# WebUser(
# username='******',
# date_joined=datetime.utcnow(),
# first_name='A',
# last_name='B',
# email='*****@*****.**',
# password='******',
# is_active=True,
# is_staff=False,
# is_superuser=True,
# ),
CommCareUser(
domain='foo',
username='******',
date_joined=datetime.utcnow(),
email='*****@*****.**',
password='******',
is_active=True,
is_staff=True,
is_superuser=False,
),
]
staging_table_loader = UserStagingLoader
@classmethod
def setUpClass(cls):
delete_all_docs_by_doc_type(WebUser.get_db(), ['CommCareUser', 'WebUser'])
super(TestUserStagingTable, cls).setUpClass()
def test_fixture_defaults(self):
user = CommCareUser(_id=uuid.uuid4().hex, domain='test-calendar-defaults')
fixture = call_fixture_generator(calendar_fixture_generator, user)[0]
self.assertEqual(user._id, fixture.attrib['user_id'])
today = datetime.today()
self._check_first_date(fixture, today - timedelta(days=DEFAULT_DAYS_BEFORE))
self._check_last_date(fixture, today + timedelta(days=DEFAULT_DAYS_AFTER))
def test_callcenter_fixture_format(self):
user = CommCareUser(_id='123')
indicator_set = MockIndicatorSet(name='test',
indicators=OrderedDict([
('user_case1', {
'i1': 1,
'i2': 2
}),
('user_case2', {
'i1': 0,
'i2': 3
})
]))
fixture = gen_fixture(user, indicator_set)
check_xml_line_by_line(
self, """
<fixture date="2014-01-01T00:00:00" id="indicators:test" user_id="{userid}">
<indicators>
<case id="user_case1">
<i1>1</i1>
<i2>2</i2>
</case>
<case id="user_case2">
<i1>0</i1>
<i2>3</i2>
</case>
</indicators>
</fixture>
""".format(userid=user.user_id), ElementTree.tostring(fixture))
def test_callcenter_fixture_commcare_user(self):
user = CommCareUser(_id='123', username="******")
indicator_set = MockIndicatorSet(name='test',
indicators=OrderedDict([
('user_case1', {
'i1': 1,
'i2': 2
}),
('user_case2', {
'i1': 0,
'i2': 3
})
]))
restore_user = type(
'OTARestoreCommCareUserFake', (OTARestoreCommCareUser, ), {
'project': Domain(name='test', default_timezone='UTC'),
'get_call_center_indicators':
lambda self, config: indicator_set,
})('test', user)
fixture, = call_fixture_generator(mock_indicators_fixture_generator,
restore_user)
check_xml_line_by_line(
self, ElementTree.tostring(fixture),
ElementTree.tostring(gen_fixture(restore_user, indicator_set)))
def create_user_for_malt_tests(is_web_user=True,
user_id='user_id',
username='******'):
user = WebUser() if is_web_user else CommCareUser()
user._id = user_id
user.username = username
user.email = 'email'
return user
def test_empty(self):
user_with_no_fields = CommCareUser(user_data={})
self.assertEqual([],
_get_invalid_user_data_fields(user_with_no_fields,
set()))
self.assertEqual([],
_get_invalid_user_data_fields(user_with_no_fields,
set(['a', 'b'])))
def test_load_session_data_for_mobile_worker(self):
user = CommCareUser(domain='cloudcare-tests',
username='******',
_id=uuid.uuid4().hex)
data = get_user_contributions_to_touchforms_session(user)
self.assertEqual('worker', data['username'])
self.assertEqual(user._id, data['user_id'])
self.assertTrue(isinstance(data['user_data'], dict))
def setUpClass(cls):
cls.domain = Domain.get_or_create_with_name(DOMAIN, is_active=True)
cls.domain.commtrack_enabled = True
cls.domain.save()
cls.user = CommCareUser(domain=DOMAIN,
domain_membership=DomainMembership(
domain=DOMAIN, location_id='1'))
cls.restore_user = cls.user.to_ota_restore_user()
def setUpClass(cls):
super(TestContent, cls).setUpClass()
cls.domain = 'test-content'
cls.user = CommCareUser(phone_numbers=['9990000000000'], language='es')
cls.translation_doc = StandaloneTranslationDoc(domain=cls.domain,
area='sms',
langs=['en', 'es'])
cls.translation_doc.save()
def is_relevant_user(user):
if user.is_deleted():
return False
if only_commcare and user.__class__ != CommCareUser().__class__:
return False
if is_active and not user.is_active:
return False
return True
def make_mobile_worker(cls, username, domain=None):
domain = domain or cls.domain
user = CommCareUser(username=username, domain=domain)
user.domain_membership = DomainMembership(domain=domain)
doc = user._doc
doc['username.exact'] = doc['username']
UserESFake.save_doc(doc)
return user
def test_only_update_once_per_day(self):
user = CommCareUser()
when = datetime(2000, 1, 1)
later = when + timedelta(hours=1)
day_later = when + timedelta(days=1)
device = 'device'
self.assertTrue(user.update_device_id_last_used(device, when))
self.assertFalse(user.update_device_id_last_used(device, later))
self.assertTrue(user.update_device_id_last_used(device, day_later))
def setUpClass(cls):
super(TestContent, cls).setUpClass()
cls.domain = 'test-content'
cls.domain_obj = create_domain(cls.domain)
cls.user = CommCareUser(phone_numbers=['9990000000000'], language='es')
from corehq.apps.sms.util import get_or_create_translation_doc
cls.translation_doc = get_or_create_translation_doc(cls.domain)
cls.translation_doc.set_translations('es', {})
cls.translation_doc.save()
def test_system_fields_not_removed(self):
user_with_system_fields = CommCareUser(
user_data={'commcare_location_id': 'foo'})
self.assertEqual([],
_get_invalid_user_data_fields(user_with_system_fields,
set()))
self.assertEqual([],
_get_invalid_user_data_fields(user_with_system_fields,
set(['a', 'b'])))
def test_add_single_device(self):
user = CommCareUser()
now = datetime.utcnow()
device_id = 'my-new-cool-phone'
self.assertEqual([], user.devices)
user.update_device_id_last_used(device_id, now)
self.assertEqual(1, len(user.devices))
device = user.devices[0]
self.assertEqual(device_id, device.device_id)
self.assertEqual(now, device.last_used)
def test_update_app_metadata(self):
user = CommCareUser()
app_meta = DeviceAppMeta(app_id='123',
build_id='build1',
build_version=1,
last_submission=datetime.utcnow(),
num_unsent_forms=1)
user.update_device_id_last_used('device', device_app_meta=app_meta)
device = user.get_device('device')
app_meta = device.get_meta_for_app('123')
self.assertIsNotNone(app_meta)
def _create_es_user(es_client, user_id, domain):
user = CommCareUser(
_id=user_id,
domain=domain,
username='******',
first_name='Harry',
last_name='Casual',
)
send_to_elasticsearch('users', user.to_json())
es_client.indices.refresh(USER_INDEX)
return user
def test_get_inactive_users_data_added(self):
CommCareUser(domain='icds-cas',
username='******').save()
CommCareUser(domain='icds-cas',
username='******').save()
IcdsFile.objects.filter(
data_type='inactive_dashboard_users').all().delete()
collect_inactive_dashboard_users()
sync = IcdsFile.objects.filter(data_type='inactive_dashboard_users'
).order_by('-file_added').first()
with sync.get_file_from_blobdb() as fileobj:
zip = zipfile.ZipFile(fileobj, 'r')
for zipped_file in zip.namelist():
csv_reader = csv.reader(zip.open(zipped_file), )
data = list(csv_reader)
sorted(data, key=lambda x: x[0])
self.assertEqual(
[['Username', 'Location', 'State'],
['*****@*****.**', '', ''],
['*****@*****.**', '', '']], data)
def _send_user_to_es(self, _id=None, is_active=True):
user = CommCareUser(
domain=self.domain,
username=self.username,
_id=_id or uuid.uuid4().hex,
is_active=is_active,
first_name=self.first_name,
last_name=self.last_name,
)
send_to_elasticsearch('users', user.to_json())
self.es.indices.refresh(USER_INDEX)
return user
def get_users(self, is_active=True, only_commcare=False):
users = [CouchUser.get_by_user_id(user_id) for user_id in self.users]
users = [user for user in users if not user.is_deleted()]
if only_commcare is True:
users = [
user for user in users
if user.__class__ == CommCareUser().__class__
]
if is_active is True:
return [user for user in users if user.is_active]
else:
return users
def test_add_second_device(self):
user = CommCareUser()
now = datetime.utcnow()
later = now + timedelta(seconds=1)
first_device = 'first-device'
second_device = 'second-device'
user.update_device_id_last_used(first_device, now)
user.update_device_id_last_used(second_device, later)
self.assertEqual(2, len(user.devices))
device_date_mapping = {device.device_id: device.last_used for device in user.devices}
self.assertEqual({first_device, second_device}, set(device_date_mapping.keys()))
self.assertEqual(now, device_date_mapping[first_device])
self.assertEqual(later, device_date_mapping[second_device])
def setUpClass(cls):
super(SyncLogPillowTest, cls).setUpClass()
DOMAIN = "synclog_test"
cls.domain = Domain(name=DOMAIN)
cls.domain.save()
cls.ccuser = CommCareUser(
domain=DOMAIN,
username='******',
last_login=datetime.datetime.now(),
date_joined=datetime.datetime.now(),
)
cls.ccuser.save()
def test_default_user_data(self):
user = CommCareUser(
domain='cloudcare-tests',
username='******',
_id=uuid.uuid4().hex
)
user_data = get_user_contributions_to_touchforms_session(user)['user_data']
for key in ['commcare_first_name', 'commcare_last_name', 'commcare_phone_number']:
self.assertEqual(None, user_data[key])
user.first_name = 'first'
user.last_name = 'last'
user_data = get_user_contributions_to_touchforms_session(user)['user_data']
self.assertEqual('first', user_data['commcare_first_name'])
self.assertEqual('last', user_data['commcare_last_name'])
def test_fixture_customization(self):
user = CommCareUser(_id=uuid.uuid4().hex, domain='test-calendar-settings')
days_before = 50
days_after = 10
calendar_settings = CalendarFixtureSettings.objects.create(
domain='test-calendar-settings',
days_before=days_before,
days_after=days_after,
)
fixture = call_fixture_generator(calendar_fixture_generator, user)[0]
self.assertEqual(user._id, fixture.attrib['user_id'])
today = datetime.today()
self._check_first_date(fixture, today - timedelta(days=days_before))
self._check_last_date(fixture, today + timedelta(days=days_after))
self.addCleanup(calendar_settings.delete)
def _send_user_to_es(self, _id=None, username=None, user_data=None):
user = CommCareUser(
domain=self.domain,
username=username or self.username,
_id=_id or uuid.uuid4().hex,
first_name=self.first_name,
last_name=self.last_name,
user_data=user_data or {},
is_active=True,
)
with patch('corehq.pillows.user.get_group_id_name_map_by_user', return_value=[]):
send_to_elasticsearch('users', transform_user_for_elasticsearch(user.to_json()))
self.es.indices.refresh(USER_INDEX)
return user
def test_normal_behavior(self):
user_with_fields = CommCareUser(user_data={
'a': 'foo',
'b': 'bar',
'c': 'baz'
})
self.assertEqual(
set(['a', 'b', 'c']),
set(_get_invalid_user_data_fields(user_with_fields, set())))
self.assertEqual(
set(['c']),
set(
_get_invalid_user_data_fields(user_with_fields, set(['a',
'b']))))
self.assertEqual(
set(['a', 'b', 'c']),
set(
_get_invalid_user_data_fields(user_with_fields, set(['e',
'f']))))
