def test_index_context_data(self):
user_stranger = factories.User(username='******')
factories.Silo(owner=user_stranger, name='open', public=True)
user = factories.User()
factories.Silo(owner=user, name='pub_1', public=True)
factories.Silo(owner=user, name='pub_2', public=True)
factories.Silo(owner=user, name='priv_1', public=False)
factories.Silo(owner=user, name='shared_1', public=False,
shared=[user_stranger])
request = self.factory.get('', follow=True)
request.user = user
context = views.IndexView()._get_context_data(request)
self.assertEqual(context['site_name'], 'Track')
self.assertEqual(len(context['silos_user']), 4)
self.assertEqual(context['silos_user'][0].name, 'pub_1')
self.assertEqual(context['silos_user'][1].name, 'pub_2')
self.assertEqual(context['silos_user'][2].name, 'priv_1')
self.assertEqual(context['silos_user_public_total'], 2)
self.assertEqual(context['silos_user_shared_total'], 1)
self.assertEqual(context['silos_public'][0].name, 'open')
self.assertEqual(len(context['silos_public']), 1)
self.assertEqual(len(context['readtypes']), 7)
self.assertEqual(sorted(list(context['readtypes'])),
[u'CSV', u'CommCare', u'CustomForm', u'GSheet Import',
u'JSON', u'ONA', u'OneDrive'])
# self.assertEqual(list(context['tags']),
# [{'name': u'security', 'times_tagged': 4},
# {'name': u'report', 'times_tagged': 4}]),
self.assertEqual(context['site_name'], 'Track'),
def test_status_danger(self, mock_merge_two_silos):
mock_merge_two_silos.return_value = {'status': 'danger'}
columns = {'name': 'name', 'type': 'text'}
left_read = factories.Read(read_name='Read Left',
owner=self.tola_user.user)
right_read = factories.Read(read_name='Read Right',
owner=self.tola_user.user)
left_silo = factories.Silo(owner=self.tola_user.user, columns=columns,
reads=[left_read])
right_silo = factories.Silo(owner=self.tola_user.user, columns=columns,
reads=[right_read])
merged_silo_name = '{}_{}'.format(left_silo.name, right_silo.name)
data = {
'left_table_id': left_silo.id,
'right_table_id': right_silo.id,
'tableMergeType': 'merge',
'columns_data': 'Test',
'merged_table_name': merged_silo_name
}
request = self.factory.post('', data=data)
request.user = self.tola_user.user
response = views.do_merge(request)
content = json.loads(response.content)
self.assertRaises(Silo.DoesNotExist,
Silo.objects.get, name=merged_silo_name)
self.assertEqual(content['status'], 'danger')
def test_no_merge_name(self, mock_merged_silos_map, mock_merge_two_silos):
mock_merge_two_silos.return_value = {'status': 'success'}
mock_merged_silos_map.return_value = Mock()
columns = {'name': 'name', 'type': 'text'}
left_read = factories.Read(read_name='Read Left',
owner=self.tola_user.user)
right_read = factories.Read(read_name='Read Right',
owner=self.tola_user.user)
left_silo = factories.Silo(owner=self.tola_user.user,
columns=columns,
reads=[left_read])
right_silo = factories.Silo(owner=self.tola_user.user,
columns=columns,
reads=[right_read])
merged_silo_name = 'Merging of {} and {}'.format(
left_silo.id, right_silo.id)
data = {
'left_table_id': left_silo.id,
'right_table_id': right_silo.id,
'tableMergeType': 'merge',
'columns_data': 'Test',
'merged_table_name': ''
}
request = self.factory.post('', data=data)
request.user = self.tola_user.user
response = views.do_merge(request)
silo = Silo.objects.get(name=merged_silo_name)
self.assertEqual(response.status_code, 302)
self.assertEqual(response.url, '/silo_detail/{}/'.format(silo.id))
self.assertIn(left_read, silo.reads.all())
self.assertIn(right_read, silo.reads.all())
def test_merge_silo_with_specified_merge_type(self):
mapping_data = """{
"0": {
"left_table_cols": ["number", "points"],
"right_table_col": "number",
"merge_type": "Avg"
},
"left_unmapped_cols": [],
"right_unmapped_cols": []
}"""
user = factories.User(username='******')
left_silo = factories.Silo(owner=user, name='left_silo', public=True)
left_silo_r = factories.LabelValueStore(silo_id=left_silo.pk)
left_silo_r['number'] = 1
left_silo_r['points'] = 5
left_silo_r.save()
left_silo_r2 = factories.LabelValueStore(silo_id=left_silo.pk)
left_silo_r2['number'] = 2
left_silo_r2['points'] = 7
left_silo_r2.save()
factories.UniqueFields(silo=left_silo, name='number')
right_silo = factories.Silo(owner=user, name='right_silo', public=True)
right_silo_r = factories.LabelValueStore(silo_id=right_silo.pk)
right_silo_r['number'] = 1
right_silo_r.save()
right_silo_r2 = factories.LabelValueStore(silo_id=right_silo.pk)
right_silo_r2['number'] = 2
right_silo_r2.save()
factories.UniqueFields(silo=right_silo, name='number')
merged_silo = factories.Silo(owner=user,
name='merged_silo',
public=True)
response = merge_two_silos(mapping_data, left_silo.pk, right_silo.pk,
merged_silo.pk)
self.assertEqual(response, {
'status': "success",
'message': "Merged data successfully"
})
merged_silo = Silo.objects.get(pk=merged_silo.pk)
self.assertEqual(
LabelValueStore.objects.filter(silo_id=merged_silo.pk).count(), 4)
merged_silo_rows = LabelValueStore.objects.filter(
silo_id=merged_silo.pk)
self.assertEqual(merged_silo_rows[0]['number'], 1)
self.assertEqual(merged_silo_rows[1]['number'], 2)
self.assertEqual(merged_silo_rows[2]['number'], 3.0)
self.assertEqual(merged_silo_rows[3]['number'], 4.5)
def test_form_with_data(self):
silo = factories.Silo()
data = {'name': 'This is the new name'}
form = forms.SiloForm(data=data, instance=silo)
self.assertTrue(form.has_changed())
self.assertEqual(form.data, data)
def test_silo_detail_import_done(self):
# Create Silo, Read and CeleryTask
read_type = factories.ReadType(read_type="CSV")
read = factories.Read(
owner=self.user, type=read_type,
read_name="TEST SILO DONE", description="unittest"
)
silo = factories.Silo(owner=self.user, public=False)
silo.reads.add(read)
factories.CeleryTask(content_object=read,
task_status=CeleryTask.TASK_FINISHED)
# Check view
request = self.factory.get(self.silo_detail_url)
request.user = self.user
response = siloDetail(request, silo.pk)
self.assertContains(
response,
'<a href="/show_read/{}" target="_blank">{}</a>'.format(
read.id, read.read_name)
)
self.assertNotContains(
response, '<span class="btn-sm btn-danger">Import Failed</span>')
self.assertNotContains(
response, '<span class="btn-sm btn-warning">Import running</span>')
self.assertNotContains(
response, '<h4 style="color:#ff3019">Import process failed</h4>')
self.assertNotContains(response, '<h4>Import process running</h4>')
def test_new_silo(self, mock_get_workflowteams):
mock_get_workflowteams.return_value = []
# Create a New Silo
silo = factories.Silo(owner=self.tola_user.user)
self.assertEqual(silo.pk, 1)
# Fetch the silo that just got created above
request = self.factory.get(self.silo_edit_url)
request.user = self.tola_user.user
response = editSilo(request, silo.pk)
self.assertEqual(response.status_code, 200)
# update the silo that just got created above
params = {
'owner': self.tola_user.user.pk,
'name': 'Test Silo Updated',
'description': 'Adding this description in a unit-test.',
}
request = self.factory.post(self.silo_edit_url, data = params)
request.user = self.tola_user.user
request._dont_enforce_csrf_checks = True
response = editSilo(request, silo.pk)
if response.status_code == 302:
self.assertEqual(response.url, "/silos/")
else:
self.assertEqual(response.status_code, 200)
def test_get_edit_silo(self, mock_get_by_url, mock_get_workflowteams):
silo = factories.Silo(owner=self.tola_user.user)
uuid = random.randint(1, 9999)
wfl1_1 = factories.WorkflowLevel1(level1_uuid=uuid,
name='Workflowlevel1 1')
uuid = random.randint(1, 9999)
wfl1_2 = factories.WorkflowLevel1(level1_uuid=uuid,
name='Workflowlevel1 2')
wfteams = [
{
'workflowlevel1': 'test.de/workflowlevel1/{}/'.format(wfl1_1.id)
}
]
wfl1_data = {
'level1_uuid': wfl1_1.level1_uuid
}
mock_get_workflowteams.return_value = wfteams
mock_get_by_url.return_value = wfl1_data
request = self.factory.get('/silo_edit/{}/'.format(silo.id),
follow=True)
request.user = self.tola_user.user
response = views.editSilo(request, silo.id)
template_content = response.content
match = 'selected>{}</option>'.format(self.tola_user.user.username)
self.assertEqual(template_content.count(match), 1)
# check if only the allowed programs are shown
self.assertEqual(template_content.count(wfl1_1.name), 1)
self.assertEqual(template_content.count(wfl1_2.name), 0)
def test_merge_silo_with_datetime_unique_field(self):
left_silo = self._create_silo('left_silo', 1, 'Bob', 'left')
factories.UniqueFields(silo=left_silo, name='created_date')
right_silo = self._create_silo('right_silo', 1, 'Marley', 'right')
factories.UniqueFields(silo=right_silo, name='created_date')
merged_silo = factories.Silo(owner=self.user,
name='merged_silo',
public=True)
response = merge_two_silos(self.mapping_data, left_silo.pk,
right_silo.pk, merged_silo.pk)
self.assertEqual(response, {
'status': "success",
'message': "Merged data successfully"
})
merged_silo = Silo.objects.get(pk=merged_silo.pk)
self.assertEqual(
LabelValueStore.objects.filter(silo_id=merged_silo.pk).count(), 1)
merged_silo_row = LabelValueStore.objects.get(silo_id=merged_silo.pk)
self.assertEqual(merged_silo_row['first name'], 'Bob')
self.assertEqual(merged_silo_row['last name'], 'Marley')
def test_merge_silos_without_mapped_columns(self):
mapping_data = """{
"0": {
"left_table_cols": [],
"right_table_col": "",
"merge_type": ""
},
"left_unmapped_cols": ["first name"],
"right_unmapped_cols": ["last name"]
}"""
left_silo = self._create_silo('left_silo', 1, 'Bob', 'left')
factories.UniqueFields(silo=left_silo, name='first name')
right_silo = self._create_silo('right_silo', 1, 'Marley', 'right')
factories.UniqueFields(silo=right_silo, name='number')
merged_silo = factories.Silo(owner=self.user,
name='merged_silo',
public=True)
response = merge_two_silos(mapping_data, left_silo.pk, right_silo.pk,
merged_silo.pk)
self.assertEqual(
response, {
'status':
"danger",
'message':
"Both silos (%s, %s) must have the same "
"column set as unique fields" %
(left_silo.name, right_silo.name)
})
def test_cannot_find_tables(self):
read = factories.Read(read_name='Read Test', owner=self.tola_user.user)
silo = factories.Silo(owner=self.tola_user.user, reads=[read])
# Do not find the left table
data = {
'left_table_id': 999,
'right_table_id': silo.id,
'merged_table_name': 'Another test'
}
request = self.factory.post('', data=data)
request.user = self.tola_user.user
response = views.do_merge(request)
self.assertEqual(response.content,
'Could not find the left table with id=999')
# Do not find the right table
data = {
'left_table_id': silo.id,
'right_table_id': 999,
'merged_table_name': 'Another test'
}
request = self.factory.post('', data=data)
request.user = self.tola_user.user
response = views.do_merge(request)
self.assertEqual(response.content,
'Could not find the right table with id=999')
def test_form_no_data(self):
silo = factories.Silo()
data = {}
form = forms.SiloForm(data=data, instance=silo)
self.assertTrue(form.has_changed())
self.assertEqual(form.data, {})
def setUp(self):
self.client = Client()
self.user = factories.User()
self.user.set_password('tola123')
self.user.save()
factories.TolaUser(user=self.user)
self.silo = factories.Silo(owner=self.user)
self.client.login(username=self.user.username, password='******')
def setUp(self):
self.factory = APIRequestFactory()
self.tola_user = factories.TolaUser()
self.read = factories.Read(read_name="test_data",
owner=self.tola_user.user)
self.silo = factories.Silo(owner=self.tola_user.user,
reads=[self.read])
self._import_json(self.silo, self.read)
def test_form_validate_success_without_form_user_and_shared(self):
silo = factories.Silo(owner=self.user)
data = {
'name': silo.name,
'owner': silo.owner.id,
}
form = forms.SiloForm(data=data, instance=silo)
self.assertTrue(form.is_valid())
def setUp(self):
factories.Organization(id=1)
self.user = factories.User(first_name='Homer', last_name='Simpson')
self.hikaya_user = factories.TolaUser(user=self.user)
self.read = factories.Read(read_name="test_data",
owner=self.hikaya_user.user)
self.silo = factories.Silo(owner=self.hikaya_user.user,
reads=[self.read])
self.factory = APIRequestFactory()
def _create_silo(self, name, number, value, option):
silo = factories.Silo(owner=self.user, name=name, public=True)
silo_row = factories.LabelValueStore(silo_id=silo.pk)
silo_row['number'] = number
if option == 'left':
silo_row['first name'] = value
elif option == 'right':
silo_row['last name'] = value
silo_row.save()
return silo
def test_form_validate_fail_without_owner(self, mock_get_workflowteams):
mock_get_workflowteams.return_value = []
silo = factories.Silo(owner=self.user)
data = {
'name': silo.name,
'shared': [self.user.id],
}
form = forms.SiloForm(user=self.user, data=data, instance=silo)
self.assertFalse(form.is_valid())
def test_form_validate_success_with_form_user(self,
mock_get_workflowteams):
mock_get_workflowteams.return_value = []
silo = factories.Silo(owner=self.user)
data = {
'name': silo.name,
'owner': silo.owner.id,
}
form = forms.SiloForm(user=self.user, data=data, instance=silo)
self.assertTrue(form.is_valid())
def test_no_columns_passed(self):
read = factories.Read(read_name='Read Test', owner=self.tola_user.user)
left_silo = factories.Silo(owner=self.tola_user.user, reads=[read])
right_silo = factories.Silo(owner=self.tola_user.user, reads=[read])
merged_silo_name = '{}_{}'.format(left_silo.name, right_silo.name)
data = {
'left_table_id': left_silo.id,
'right_table_id': right_silo.id,
'tableMergeType': 'merge',
'merged_table_name': merged_silo_name
}
request = self.factory.post('', data=data)
request.user = self.tola_user.user
response = views.do_merge(request)
self.assertRaises(Silo.DoesNotExist,
Silo.objects.get, name=merged_silo_name)
self.assertEqual(response.content, 'No columns data passed')
def test_list_silo_shared(self):
user = factories.User(first_name='Marge', last_name='Simpson')
factories.Silo(owner=user, shared=[self.user])
request = self.factory.get('/api/silo/?user_uuid={}'.format(
self.tola_user.tola_user_uuid))
request.user = self.tola_user.user
view = SiloViewSet.as_view({'get': 'list'})
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
def test_retrieve_silo_normal_user(self):
request = self.factory.get('/api/silo/')
request.user = self.tola_user.user
view = SiloViewSet.as_view({'get': 'retrieve'})
response = view(request, id=self.silos[0].id)
self.assertEqual(response.status_code, 404)
silo = factories.Silo(name='My Silo', owner=self.tola_user.user)
response = view(request, id=silo.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['name'], silo.name)
def setUp(self):
self.org = factories.Organization()
self.hikaya_user = factories.TolaUser(organization=self.org)
self.read = factories.Read(read_name="test_data",
owner=self.hikaya_user.user)
self.silo = factories.Silo(owner=self.hikaya_user.user,
reads=[self.read])
self._import_json(self.silo, self.read)
self.factory = APIRequestFactory()
def test_list_silo_normal_user(self):
request = self.factory.get('/api/silo/')
request.user = self.tola_user.user
view = SiloViewSet.as_view({'get': 'list'})
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
factories.Silo(owner=self.tola_user.user)
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
def test_get_edit_silo_no_teams(self, mock_get_workflowteams):
silo = factories.Silo(owner=self.tola_user.user)
wfteams = []
mock_get_workflowteams.return_value = wfteams
request = self.factory.get('/silo_edit/{}/'.format(silo.id),
follow=True)
request.user = self.tola_user.user
response = views.editSilo(request, silo.id)
template_content = response.content
match = 'selected>{}</option>'.format(self.tola_user.user.username)
self.assertEqual(template_content.count(match), 1)
def test_form_validate_success_change_owner(self, mock_get_workflowteams):
mock_get_workflowteams.return_value = []
user = factories.User(first_name='Homer', last_name='Simpson')
factories.TolaUser(user=user, organization=self.tola_user.organization)
silo = factories.Silo(owner=self.user)
data = {
'name': silo.name,
'owner': user.id,
}
form = forms.SiloForm(user=self.user, data=data, instance=silo)
self.assertTrue(form.is_valid())
def test_has_data_customform_normaluser(self):
wflvl1 = factories.WorkflowLevel1(
organization=self.hikaya_user.organization)
silo = factories.Silo(workflowlevel1=[wflvl1],
owner=self.hikaya_user.user,
public=False)
request = self.factory.get('api/customform/%s/has_data' % 11)
request.user = self.hikaya_user.user
view = CustomFormViewSet.as_view({'get': 'has_data'})
response = view(request, pk=silo.pk)
self.assertEqual(response.status_code, 403)
def setUp(self):
self.factory = APIRequestFactory()
self.tola_user = factories.TolaUser()
self.read = factories.Read(read_name="test_data",
owner=self.tola_user.user)
self.silo = factories.Silo(owner=self.tola_user.user,
reads=[self.read])
# Have to remove the created lvs
lvss = LabelValueStore.objects.filter(silo_id=self.silo.id)
for lvs in lvss:
lvs.delete()
self._import_json(self.silo, self.read)
def setUp(self):
self.client = Client()
self.user = factories.User()
self.user.set_password('tola123')
self.user.save()
self.read_type = ReadType.objects.create(read_type="Ona")
self.read = Read.objects.create(
read_name="test_read1", owner=self.user, type=self.read_type,
read_url='http://mysafeinfo.com/api/data?list='
'englishmonarchs&format=json')
self.silo = factories.Silo(owner=self.user, reads=[self.read])
factories.TolaUser(user=self.user)
self.client.login(username=self.user.username, password='******')
def test_data_silo_empty_table(self):
read = factories.Read(read_name="test_empty",
owner=self.tola_user.user)
silo = factories.Silo(owner=self.tola_user.user, reads=[read])
request = self.factory.get('/api/silo/{}/data'.format(silo.id))
request.user = self.tola_user.user
view = SiloViewSet.as_view({'get': 'data'})
response = view(request, id=silo.id)
self.assertEqual(response.status_code, 200)
json_content = json.loads(response.content)
self.assertEqual(json_content['recordsTotal'], 0)
self.assertEqual(json_content['recordsFiltered'], 0)
