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_onaParserOneLayer(self):
self.assertEqual(getProjects(self.user.id), [])
self.read = factories.Read(
read_name="test_read1", owner=self.user, type=self.read_type,
read_url="https://www.commcarehq.org/a/a/"
)
self.assertEqual(getProjects(self.user.id), ['a'])
self.read = factories.Read(
read_name="test_read2", owner=self.user, type=self.read_type,
read_url="https://www.commcarehq.org/a/b/"
)
self.assertEqual(getProjects(self.user.id), ['a', 'b'])
self.read = factories.Read(
read_name="test_read3", owner=self.user, type=self.read_type,
read_url="https://www.commcarehq.org/a/b/"
)
self.assertEqual(getProjects(self.user.id), ['a', 'b'])
self.read = factories.Read(
read_name="test_read4", owner=self.user2, type=self.read_type,
read_url="https://www.commcarehq.org/a/c/"
)
self.assertEqual(getProjects(self.user.id), ['a', 'b'])
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_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 setUp(self):
self.factory = APIRequestFactory()
self.hikaya_user = factories.TolaUser()
self.read = factories.Read(read_name="test_data",
owner=self.hikaya_user.user)
self.read_type = factories.ReadType.create(read_type='CSV')
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 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 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_read_owner(self):
request = self.factory.get('/api/read/')
request.user = self.hikaya_user.user
view = ReadViewSet.as_view({'get': 'list'})
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
factories.Read(owner=self.hikaya_user.user)
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
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 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)
def test_list_read_public(self):
request = self.factory.get('/api/read/')
request.user = self.tola_user.user
view = ReadViewSet.as_view({'get': 'list'})
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
owner = factories.User()
read = factories.Read(read_name='It is public', owner=owner)
factories.Silo(public=True, reads=[read])
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
def test_list_read_shared(self):
request = self.factory.get('/api/read/')
request.user = self.hikaya_user.user
view = ReadViewSet.as_view({'get': 'list'})
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
owner = factories.User()
read = factories.Read(read_name='It is shared', owner=owner)
factories.Silo(shared=[self.hikaya_user.user], reads=[read])
response = view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
def test_retrieve_read_shared(self):
shared_user = factories.User(is_superuser=False, is_staff=False)
request = self.factory.get('/api/read/')
request.user = shared_user
view = ReadViewSet.as_view({'get': 'retrieve'})
response = view(request, pk=self.read.id)
self.assertEqual(response.status_code, 404)
read = factories.Read(read_name='It is shared',
owner=self.hikaya_user.user)
factories.Silo(shared=[shared_user], reads=[read])
response = view(request, pk=read.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['read_name'], 'It is shared')
def test_list_reports_shared_with_organization(self):
read = factories.Read(read_name="test_data",
owner=self.tola_user.user)
factories.Silo(name='Test Share Report',
owner=self.tola_user.user,
reads=[read],
public=False,
shared=[],
share_with_organization=True)
request = self.factory.get('')
request.user = self.tola_user.user
response = views.list_table_dashboards(request)
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Test Share Report')
def test_retrieve_read_public(self):
user = factories.User(is_superuser=False, is_staff=False)
request = self.factory.get('/api/read/')
request.user = user
view = ReadViewSet.as_view({'get': 'retrieve'})
response = view(request, pk=self.read.id)
self.assertEqual(response.status_code, 404)
read = factories.Read(read_name='It is public',
owner=self.tola_user.user)
factories.Silo(public=True, reads=[read])
response = view(request, pk=read.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['read_name'], 'It is public')
def test_celery_failure(self):
silo = factories.Silo(owner=self.user, public=False)
read_type = factories.ReadType(read_type="CSV")
upload_file = open('silo/tests/sample_data/test_broken.csv', 'rb')
read = factories.Read(owner=self.user, type=read_type, file_data=SimpleUploadedFile(upload_file.name, upload_file.read()))
task = factories.CeleryTask(content_object=read)
process_silo(silo.id, read.id)
ctask = CeleryTask.objects.get(
object_id=read.id,
content_type=ContentType.objects.get_for_model(Read)
)
self.assertEqual(ctask.task_id, task.task_id)
self.assertEqual(ctask.task_status, CeleryTask.TASK_FAILED)
def test_celery_success(self):
"""
Test if the celery task process_silo actually imports data
:return:
"""
silo = factories.Silo(owner=self.user, public=False)
read_type = factories.ReadType(read_type="CSV")
upload_file = open('silo/tests/sample_data/test.csv', 'rb')
read = factories.Read(owner=self.user, type=read_type, file_data=SimpleUploadedFile(upload_file.name, upload_file.read()))
task = factories.CeleryTask(task_status=CeleryTask.TASK_CREATED, content_object=read)
process_done = process_silo(silo.id, read.id)
self.assertEqual(getSiloColumnNames(silo.id), ['First_Name', 'Last_Name', 'E-mail'])
self.assertTrue(process_done)
def test_new_silodata(self, mock_get_workflowteams):
mock_get_workflowteams.return_value = []
read_type = ReadType.objects.get(read_type="CSV")
upload_file = open('silo/tests/sample_data/test.csv', 'rb')
read = factories.Read(owner=self.tola_user.user,
type=read_type,
read_name="TEST CSV IMPORT",
description="unittest",
file_data=SimpleUploadedFile(
upload_file.name, upload_file.read()))
params = {
"read_id": read.pk,
"new_silo": "Test CSV Import",
}
request = self.factory.post(self.upload_csv_url, data=params)
request.user = self.tola_user.user
request._dont_enforce_csrf_checks = True
response = uploadFile(request, read.pk)
self.assertEqual(response.status_code, 302)
self.assertIn("/silo_detail/", response.url)
silo = Silo.objects.get(name="Test CSV Import")
request = self.factory.get(self.silo_detail_url)
request.user = self.tola_user.user
response = silo_detail(request, silo.pk)
self.assertEqual(response.status_code, 200)
# now delete that silo data cause this uses the custom database
LabelValueStore.objects.filter(First_Name="Bob",
Last_Name="Smith",
silo_id="1",
read_id="1").delete()
LabelValueStore.objects.filter(First_Name="John",
Last_Name="Doe",
silo_id="1",
read_id="1").delete()
LabelValueStore.objects.filter(First_Name="Joe",
Last_Name="Schmoe",
silo_id="1",
read_id="1").delete()
LabelValueStore.objects.filter(First_Name="جان",
Last_Name="ډو",
silo_id="1",
read_id="1").delete()
def test_update_read_super_user(self):
self.hikaya_user.user.is_superuser = True
self.hikaya_user.user.save()
another_user = factories.User(first_name='Homer', last_name='Simpson')
silo = factories.Silo(owner=another_user, public=True)
new_read = factories.Read(read_name="test_data",
autopull_frequency="daily",
autopush_frequency="daily",
owner=another_user)
silo.reads.add(new_read)
data = {
"type": reverse('readtype-detail',
kwargs={'pk': self.read_type.id}),
"owner": reverse('user-detail',
kwargs={'pk': self.hikaya_user.user.id}),
"autopull_frequency": "weekly",
"autopush_frequency": "weekly",
}
request = self.factory.post('/api/read/', data)
request.user = self.hikaya_user.user
view = ReadViewSet.as_view({'post': 'update'})
response = view(request, pk=new_read.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['read_name'],
new_read.read_name)
self.assertEqual(response.data['autopull_frequency'],
data['autopull_frequency'])
self.assertEqual(response.data['autopush_frequency'],
data['autopush_frequency'])
self.assertContains(response, "/api/users/" + str(
self.hikaya_user.user.id), status_code=200)
self.assertContains(response, "/api/readtype/" + str(
self.read_type.id), status_code=200)
updated_read = Read.objects.get(id=new_read.pk)
self.assertEqual(updated_read.autopull_frequency,
data["autopull_frequency"])
self.assertEqual(updated_read.autopush_frequency,
data["autopush_frequency"])
def test_silo_detail_import_failed(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 FAIL", description="unittest"
)
silo = factories.Silo(owner=self.user, public=False)
silo.reads.add(read)
task = factories.CeleryTask(content_object=read, task_status=CeleryTask.TASK_FAILED)
# 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/"+str(read.id)+"\" target=\"_blank\">"+read.read_name+"</a>")
self.assertContains(response, "<span class=\"btn-sm btn-danger\">Import Failed</span>")
self.assertContains(response, "<h4 style=\"color:#ff3019\">Import process failed</h4>")
def test_upload_file(self):
"""
Checks if uploadFile successfully creates a celery task and new silo
for imported read
uploadFile takes POST request with csv file
- takes a Read
- adds read to a silo
- creates a CeleryTask
- redirects to silo_detail
:return:
"""
read_type = factories.ReadType(read_type="CSV")
upload_file = open('silo/tests/sample_data/test.csv', 'rb')
read = factories.Read(
owner=self.user, type=read_type,
read_name="TEST UPLOADFILE", description="unittest",
file_data=SimpleUploadedFile(upload_file.name, upload_file.read())
)
self.assertEqual(Silo.objects.filter(reads=read.pk).count(), 0)
params = {
"read_id": read.pk,
"new_silo": "TEST UPLOADFILE",
}
request = self.factory.post(self.upload_csv_url, data=params)
request.user = self.user
request._dont_enforce_csrf_checks = True
response = uploadFile(request, read.pk)
self.assertEqual(response.status_code, 302)
self.assertIn("/silo_detail/", response.url)
# assure new Silo was created
new_silo = Silo.objects.get(reads=read.pk)
self.assertEqual(new_silo.name, params["new_silo"])
# assure CeleryTask was created
ctask = CeleryTask.objects.get(
object_id=read.pk,
content_type=ContentType.objects.get_for_model(Read)
)
self.assertNotEqual(ctask.task_id, None)
self.assertEqual(ctask.task_status, CeleryTask.TASK_CREATED)
def test_list_reports_not_share_with_organization(self):
request_user = factories.User(username='******')
factories.TolaUser(user=request_user,
organization=self.hikaya_user.organization)
read = factories.Read(read_name="test_data",
owner=self.hikaya_user.user)
factories.Silo(name='Test Share Report',
owner=self.hikaya_user.user,
reads=[read],
public=False,
shared=[],
share_with_organization=False)
request = self.factory.get('')
request.user = request_user
response = views.list_table_dashboards(request)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, 'Test Share Report')
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 setUp(self):
self.factory = APIRequestFactory()
self.tola_user = factories.TolaUser()
self.read = factories.Read(
owner=self.tola_user.user,
type=factories.ReadType(read_type='CustomForm'),
read_name='Lennon Survey',
)
wflvl1 = factories.WorkflowLevel1(
organization=self.tola_user.organization)
self.silo = factories.Silo(
name='Lennon Survey',
workflowlevel1=[wflvl1],
owner=self.tola_user.user,
columns='[{"name": "name", "type": "text"},'
'{"name": "age", "type": "number"},'
'{"name": "city", "type": "text"}]',
reads=[self.read],
public=False
)
def test_save_and_import_read_without_silo_id(self, mock_requests):
data_res = {'detail': 'Success'}
mock_requests.get.return_value = Mock(content=json.dumps(data_res))
read = factories.Read(read_name='Read Test', owner=self.tola_user.user)
silo = factories.Silo(owner=self.tola_user.user, reads=[read])
factories.ThirdPartyTokens(user=self.tola_user.user, name='ONA')
factories.ReadType(read_type='ONA')
data = {
'read_name': read.read_name,
'description': silo.description,
'silo_name': silo.name
}
request = self.factory.post('', data)
request.user = self.tola_user.user
response = views.saveAndImportRead(request)
content = response.content
self.assertEqual('Silo ID can only be an integer', content)
def test_update_read_not_owner(self):
another_user = factories.User(first_name='Homer', last_name='Simpson')
silo = factories.Silo(owner=another_user, public=True)
new_read = factories.Read(read_name="test_data",
autopull_frequency="daily",
autopush_frequency="daily",
owner=another_user)
silo.reads.add(new_read)
data = {
"type": reverse('readtype-detail',
kwargs={'pk': self.read_type.id}),
"autopull_frequency": "weekly",
"autopush_frequency": "weekly",
}
request = self.factory.post('/api/read/', data)
request.user = self.hikaya_user.user
view = ReadViewSet.as_view({'post': 'update'})
response = view(request, pk=new_read.pk)
self.assertEqual(response.status_code, 403)
def test_save_and_import_read_without_data(self, mock_requests):
mock_requests.get.return_value = Mock(content='[]')
read = factories.Read(read_name='Read Test', owner=self.tola_user.user)
silo = factories.Silo(owner=self.tola_user.user, reads=[read])
factories.ThirdPartyTokens(user=self.tola_user.user, name='ONA')
factories.ReadType(read_type='ONA')
data = {
'read_name': read.read_name,
'description': silo.description,
'silo_id': silo.id,
'silo_name': silo.name
}
request = self.factory.post('', data)
request.user = self.tola_user.user
response = views.saveAndImportRead(request)
content = response.content
self.assertEqual('There is not data for the selected form, {}'.format(
read.read_name), content)
def test_update_read_owner(self):
new_read = factories.Read(read_name="test_data",
autopull_frequency="daily",
autopush_frequency="daily",
owner=self.hikaya_user.user)
data = {
"type": reverse('readtype-detail',
kwargs={'pk': self.read_type.id}),
"owner": reverse('user-detail',
kwargs={'pk': self.hikaya_user.user.id}),
"autopull_frequency": "weekly",
"autopush_frequency": "weekly",
}
request = self.factory.post('/api/read/', data)
request.user = self.hikaya_user.user
view = ReadViewSet.as_view({'post': 'update'})
response = view(request, pk=new_read.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['read_name'],
new_read.read_name)
self.assertEqual(response.data['autopull_frequency'],
data['autopull_frequency'])
self.assertEqual(response.data['autopush_frequency'],
data['autopush_frequency'])
self.assertContains(response, "/api/users/" + str(
self.hikaya_user.user.id), status_code=200)
self.assertContains(response, "/api/readtype/" + str(
self.read_type.id), status_code=200)
updated_read = Read.objects.get(id=new_read.pk)
self.assertEqual(updated_read.autopull_frequency,
data["autopull_frequency"])
self.assertEqual(updated_read.autopush_frequency,
data["autopush_frequency"])
