def setup_models(self):
self.project = ProjectFactory.create()
self.relationship = TenureRelationshipFactory.create(
project=self.project)
self.attached = ResourceFactory.create(
project=self.project, content_object=self.relationship)
self.unattached = ResourceFactory.create(project=self.project)
def test_archived_resources_not_listed(self):
ResourceFactory.create(
project=self.prj, content_object=self.su, archived=True)
response = self.request(user=self.user)
assert response.status_code == 200
assert len(response.content) == 2
returned_ids = [r['id'] for r in response.content]
assert all(res.id in returned_ids for res in self.resources)
def setup_models(self):
self.user = UserFactory.create()
assign_policies(self.user)
self.prj = ProjectFactory.create(slug='test-project', access='public')
self.su = SpatialUnitFactory.create(project=self.prj)
self.resources = ResourceFactory.create_batch(
2, project=self.prj, content_object=self.su)
ResourceFactory.create(project=self.prj)
self.file = self.get_file('/resources/tests/files/image.jpg', 'rb')
self.file_name = self.storage.save('resources/image.jpg', self.file)
def setup_models(self):
self.prj = ProjectFactory.create()
self.tenure = TenureRelationshipFactory.create(project=self.prj)
self.resource = ResourceFactory.create(content_object=self.tenure,
project=self.prj)
self.user = UserFactory.create()
assign_policies(self.user)
def test_add_existing_resource(self):
new_resource = ResourceFactory.create()
data = {'id': new_resource.id}
response = self.request(method='POST', user=self.user, post_data=data)
assert response.status_code == 201
assert self.tenure.resources.count() == 3
assert new_resource in self.tenure.resources
def test_add_existing_resource(self):
new_resource = ResourceFactory.create()
data = {'id': new_resource.id}
response = self.request(method='POST', user=self.user, post_data=data)
assert response.status_code == 201
assert self.su.resources.count() == 3
assert new_resource in self.su.resources
def setup_models(self):
self.prj = ProjectFactory.create()
self.su = SpatialUnitFactory.create(project=self.prj)
self.resource = ResourceFactory.create(content_object=self.su,
project=self.prj)
self.user = UserFactory.create()
assign_policies(self.user)
def setup_models(self):
self.user = UserFactory.create()
assign_policies(self.user)
self.project = ProjectFactory.create(slug='test-project')
QuestionnaireFactory.create(project=self.project)
content_type = ContentType.objects.get(app_label='party',
model='party')
create_attrs_schema(project=self.project,
dict=individual_party_xform_group,
content_type=content_type,
errors=[])
create_attrs_schema(project=self.project,
dict=default_party_xform_group,
content_type=content_type,
errors=[])
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
create_attrs_schema(project=self.project,
dict=tenure_relationship_xform_group,
content_type=content_type,
errors=[])
self.su = SpatialUnitFactory.create(project=self.project, type='CB')
self.party = PartyFactory.create(project=self.project,
type='IN',
attributes={
'gender': 'm',
'homeowner': 'yes',
'dob': '1951-05-05'
})
self.tenure_rel = TenureRelationshipFactory.create(
spatial_unit=self.su,
party=self.party,
project=self.project,
attributes={'notes': 'PBS is the best.'})
self.resource = ResourceFactory.create(project=self.project)
self.results = get_fake_es_api_results(self.project, self.su,
self.party, self.tenure_rel,
self.resource)
self.proj_result = self.results['hits']['hits'][0]
self.su_result = self.results['hits']['hits'][1]
self.party_result = self.results['hits']['hits'][2]
self.tenure_rel_result = self.results['hits']['hits'][3]
self.resource_result = self.results['hits']['hits'][4]
self.query = 'searching'
self.query_body = {
'query': {
'simple_query_string': {
'default_operator': 'and',
'query': self.query,
}
}
}
self.es_endpoint = '{}/project-{}/_search'.format(
api_url, self.project.id)
self.es_body = json.dumps(self.query_body, sort_keys=True)
def setup_models(self):
self.prj = ProjectFactory.create()
self.party = PartyFactory.create(project=self.prj)
self.resource = ResourceFactory.create(content_object=self.party,
project=self.prj)
self.user = UserFactory.create()
assign_policies(self.user)
def setup_models(self):
self.prj = ProjectFactory.create()
self.su = SpatialUnitFactory.create(project=self.prj)
self.resource = ResourceFactory.create(content_object=self.su,
project=self.prj)
self.user = UserFactory.create()
assign_policies(self.user)
def test_get_related_resources(self):
resource = ResourceFactory.create(status=RESOURCE_APPROVED,
tags=TagFactory.create_batch(10))
tag = resource.tags.all()[0]
tag_1 = resource.tags.all()[1]
tag_2 = resource.tags.all()[2]
resource_2 = ResourceFactory.create(status=RESOURCE_APPROVED,
tags=[tag])
resource_3 = ResourceFactory.create(status=RESOURCE_APPROVED,
tags=[tag_1, tag_2])
resource_4 = ResourceFactory.create(status=RESOURCE_APPROVED,
tags=[tag, tag_1, tag_2])
resources = resource.get_related()
self.assertEqual(resource_4.id, resources[0].id)
self.assertEqual(resource_3.id, resources[1].id)
self.assertEqual(resource_2.id, resources[2].id)
def setup_models(self):
self.prj = ProjectFactory.create()
self.tenure = TenureRelationshipFactory.create(
project=self.prj)
self.resource = ResourceFactory.create(content_object=self.tenure,
project=self.prj)
self.user = UserFactory.create()
assign_policies(self.user)
def setup_models(self):
self.user = UserFactory.create()
assign_policies(self.user)
self.project = ProjectFactory.create(slug='test-project')
QuestionnaireFactory.create(project=self.project)
content_type = ContentType.objects.get(
app_label='party', model='party')
create_attrs_schema(
project=self.project, dict=individual_party_xform_group,
content_type=content_type, errors=[])
create_attrs_schema(
project=self.project, dict=default_party_xform_group,
content_type=content_type, errors=[])
content_type = ContentType.objects.get(
app_label='party', model='tenurerelationship')
create_attrs_schema(
project=self.project, dict=tenure_relationship_xform_group,
content_type=content_type, errors=[])
self.su = SpatialUnitFactory.create(project=self.project, type='CB')
self.party = PartyFactory.create(
project=self.project,
type='IN',
attributes={
'gender': 'm',
'homeowner': 'yes',
'dob': '1951-05-05'
})
self.tenure_rel = TenureRelationshipFactory.create(
spatial_unit=self.su, party=self.party, project=self.project,
attributes={'notes': 'PBS is the best.'})
self.resource = ResourceFactory.create(project=self.project)
self.results = get_fake_es_api_results(
self.project, self.su, self.party, self.tenure_rel, self.resource)
self.proj_result = self.results['hits']['hits'][0]
self.su_result = self.results['hits']['hits'][1]
self.party_result = self.results['hits']['hits'][2]
self.tenure_rel_result = self.results['hits']['hits'][3]
self.resource_result = self.results['hits']['hits'][4]
self.query = 'searching'
self.query_body = {
'query': {
'simple_query_string': {
'default_operator': 'and',
'query': self.query,
}
},
'from': 10,
'size': 20,
'sort': {'_score': {'order': 'desc'}},
}
self.es_endpoint = '{}/project-{}/_search/'.format(api_url,
self.project.id)
self.es_body = json.dumps(self.query_body, sort_keys=True)
def test_make_download(self):
ensure_dirs()
project = ProjectFactory.create()
exporter = ResourceExporter(project)
ResourceFactory.create(project=project, original_file='res.png')
ResourceFactory.create(project=project, original_file='res.png')
ResourceFactory.create(project=project, original_file='resources.xlsx')
deleted = ResourceFactory.create(project=project,
original_file='image1.jpg',
archived=True)
t = round(time.time() * 1000)
path, mime = exporter.make_download('res-test-' + str(t))
assert path == os.path.join(settings.MEDIA_ROOT,
'temp/res-test-{}.zip'.format(t))
assert mime == 'application/zip'
with ZipFile(path, 'r') as testzip:
assert len(testzip.namelist()) == 4
assert 'res.png' in testzip.namelist()
assert 'res_1.png' in testzip.namelist()
assert 'resources_1.xlsx' in testzip.namelist()
assert 'resources.xlsx' in testzip.namelist()
assert deleted.original_file not in testzip.namelist()
def setUp(self):
self.url = reverse('resource-list')
self.resource_1 = ResourceFactory.create(status=RESOURCE_APPROVED)
self.like_url = reverse('resource-like', kwargs={'pk': self.resource_1.id})
self.tried_url = reverse('resource-tried', kwargs={'pk': self.resource_1.id})
self.organisation = OrganisationFactory.create()
self.user = UserFactory.create(
is_staff=True, approved_organisations=[self.organisation], password='******'
)
self.logged_in_client = APIClient()
self.logged_in_client.login(username=self.user.email, password='******')
ResourceFactory.create(status=RESOURCE_REJECTED)
ResourceFactory.create(privacy=[self.organisation], status=RESOURCE_APPROVED)
self.url = reverse('resource-list')
self.update_url = reverse('resource-detail', kwargs={'pk': self.resource_1.id})
def test_delete_resource_with_invalid_resource(self):
new_resource = ResourceFactory.create(project=self.prj)
response = self.request(method='DELETE', user=self.user, url_kwargs={
'resource': new_resource.id
})
assert response.status_code == 404
assert response.content['detail'] == "Not found."
assert len(self.su.resources) == 1
assert Resource.objects.filter(
id=self.resource.id, project=self.prj).exists()
def test_delete_resource_with_invalid_resource(self):
new_resource = ResourceFactory.create(project=self.prj)
response = self.request(method='DELETE',
user=self.user,
url_kwargs={'resource': new_resource.id})
assert response.status_code == 404
assert response.content['detail'] == "Not found."
assert len(self.su.resources) == 1
assert Resource.objects.filter(id=self.resource.id,
project=self.prj).exists()
def test_detach_party_resources(self):
project = ProjectFactory.create()
party = PartyFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(content_object=party)
assert ContentObject.objects.filter(object_id=party.id,
resource=resource).exists()
assert resource in party.resources
party.delete()
assert not ContentObject.objects.filter(object_id=party.id,
resource=resource).exists()
def test_detach_spatial_unit_resources(self):
project = ProjectFactory.create()
su = SpatialUnitFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(content_object=su)
assert ContentObject.objects.filter(
object_id=su.id,
resource=resource,
).exists()
assert resource in su.resources
su.delete()
assert not ContentObject.objects.filter(object_id=su.id,
resource=resource).exists()
def test_detach_tenure_relationship_resources(self):
project = ProjectFactory.create()
tenure = TenureRelationshipFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(
content_object=tenure)
assert ContentObject.objects.filter(
object_id=tenure.id,
resource=resource,).exists()
assert resource in tenure.resources
tenure.delete()
assert not ContentObject.objects.filter(
object_id=tenure.id, resource=resource).exists()
def test_detach_party_resources(self):
project = ProjectFactory.create()
party = PartyFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(
content_object=party)
assert ContentObject.objects.filter(
object_id=party.id, resource=resource).exists()
assert resource in party.resources
party.delete()
assert not ContentObject.objects.filter(
object_id=party.id, resource=resource).exists()
def test_detach_spatial_unit_resources(self):
project = ProjectFactory.create()
su = SpatialUnitFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(
content_object=su)
assert ContentObject.objects.filter(
object_id=su.id,
resource=resource,).exists()
assert resource in su.resources
su.delete()
assert not ContentObject.objects.filter(
object_id=su.id, resource=resource).exists()
def test_detach_tenure_relationship_resources(self):
project = ProjectFactory.create()
tenure = TenureRelationshipFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(content_object=tenure)
assert ContentObject.objects.filter(
object_id=tenure.id,
resource=resource,
).exists()
assert resource in tenure.resources
tenure.delete()
assert not ContentObject.objects.filter(object_id=tenure.id,
resource=resource).exists()
def setup_models(self):
self.project = ProjectFactory.create(slug='test-project')
self.location = SpatialUnitFactory.create(
project=self.project,
geometry='SRID=4326;POINT(0 0)',
)
self.party1 = PartyFactory.create(project=self.project)
self.party2 = PartyFactory.create(project=self.project)
self.tenure_rel = TenureRelationshipFactory.create(
project=self.project,
spatial_unit=self.location,
party=self.party1,
)
self.resource = ResourceFactory.create(project=self.project)
def test_user_resources(self):
ResourceFactory.create(
privacy=[self.organisation, self.organisation_1],
status=RESOURCE_APPROVED)
ResourceFactory.create(privacy=[self.organisation_1],
status=RESOURCE_APPROVED)
ResourceFactory.create_batch(size=2, status=RESOURCE_APPROVED)
ResourceFactory.create(status=RESOURCE_REJECTED)
self.assertEqual(Resource.objects.approved(self.user).count(), 3)
def test_make_download(self):
ensure_dirs()
project = ProjectFactory.create()
exporter = ResourceExporter(project)
res = ResourceFactory.create(project=project)
t = round(time.time() * 1000)
path, mime = exporter.make_download("res-test-" + str(t))
assert path == os.path.join(settings.MEDIA_ROOT, "temp/res-test-{}.zip".format(t))
assert mime == "application/zip"
with ZipFile(path, "r") as testzip:
assert len(testzip.namelist()) == 2
assert res.original_file in testzip.namelist()
assert "resources.xlsx" in testzip.namelist()
def test_detach_deferred_party_resources(self):
project = ProjectFactory.create()
party = PartyFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(content_object=party)
assert ContentObject.objects.filter(object_id=party.id,
resource=resource).exists()
party_deferred = Party.objects.all().defer('attributes')[0]
assert resource in party_deferred.resources
party_deferred.delete()
assert not ContentObject.objects.filter(object_id=party.id,
resource=resource).exists()
assert Party.objects.all().count() == 0
def test_make_download(self):
ensure_dirs()
project = ProjectFactory.create()
exporter = ResourceExporter(project)
res = ResourceFactory.create(project=project)
t = round(time.time() * 1000)
path, mime = exporter.make_download('res-test-' + str(t))
assert path == os.path.join(settings.MEDIA_ROOT,
'temp/res-test-{}.zip'.format(t))
assert mime == 'application/zip'
with ZipFile(path, 'r') as testzip:
assert len(testzip.namelist()) == 2
assert res.original_file in testzip.namelist()
assert 'resources.xlsx' in testzip.namelist()
def test_detach_deferred_spatial_unit_resources(self):
project = ProjectFactory.create()
su = SpatialUnitFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(content_object=su)
assert ContentObject.objects.filter(
object_id=su.id,
resource=resource,
).exists()
su_deferred = SpatialUnit.objects.all().defer('attributes')[0]
assert resource in su_deferred.resources
su_deferred.delete()
assert not ContentObject.objects.filter(object_id=su.id,
resource=resource).exists()
assert SpatialUnit.objects.all().count() == 0
def test_detach_deferred_party_resources(self):
project = ProjectFactory.create()
party = PartyFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(
content_object=party)
assert ContentObject.objects.filter(
object_id=party.id, resource=resource).exists()
party_deferred = Party.objects.all().defer('attributes')[0]
assert resource in party_deferred.resources
party_deferred.delete()
assert not ContentObject.objects.filter(
object_id=party.id, resource=resource).exists()
assert Party.objects.all().count() == 0
def test_detach_deferred_spatial_unit_resources(self):
project = ProjectFactory.create()
su = SpatialUnitFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(
content_object=su)
assert ContentObject.objects.filter(
object_id=su.id,
resource=resource,).exists()
su_deferred = SpatialUnit.objects.all().defer('attributes')[0]
assert resource in su_deferred.resources
su_deferred.delete()
assert not ContentObject.objects.filter(
object_id=su.id, resource=resource).exists()
assert SpatialUnit.objects.all().count() == 0
def setup_models(self):
self.project = ProjectFactory.create(slug='test-project')
self.location = SpatialUnitFactory.create(
project=self.project,
geometry='SRID=4326;POINT(0 0)',
)
self.party1 = PartyFactory.create(project=self.project)
self.party2 = PartyFactory.create(project=self.project)
self.tenure_rel = TenureRelationshipFactory.create(
project=self.project,
spatial_unit=self.location,
party=self.party1,
)
self.resource = ResourceFactory.create(project=self.project)
self.query_format = ('{{"query": {{"bool": {{"should": ['
'{{"multi_match": {{"query": "{q}"}}}}]}}}},'
' "from": {f}, "size": {s}}}')
def test_detach_deferred_tenure_relationship_resources(self):
project = ProjectFactory.create()
tenure = TenureRelationshipFactory.create(project=project)
resource = ResourceFactory.create(project=project)
resource.content_objects.create(
content_object=tenure)
assert ContentObject.objects.filter(
object_id=tenure.id,
resource=resource,).exists()
tenure_deferred = TenureRelationship.objects.all(
).defer('attributes')[0]
assert resource in tenure_deferred.resources
tenure_deferred.delete()
assert not ContentObject.objects.filter(
object_id=tenure.id, resource=resource).exists()
assert TenureRelationship.objects.all().count() == 0
def setUp(self):
super().setUp()
PolicyFactory.load_policies()
test_objs = load_test_data(get_test_data())
self.org = test_objs['organizations'][0]
self.prj = test_objs['projects'][1]
OrganizationRole.objects.create(organization=self.org,
user=UserFactory.create(
username='******',
password='******'),
admin=True)
ResourceFactory.create_batch(2,
content_object=self.prj,
project=self.prj)
su = SpatialUnitFactory(geometry=GEOSGeometry(
'{"type": "Polygon",'
'"coordinates": [['
'[-5.1031494140625000,'
' 8.1299292850467957], '
'[-5.0482177734375000, '
'7.6837733211111425], '
'[-4.6746826171875000, '
'7.8252894725496338], '
'[-4.8641967773437491, '
'8.2278005261522775], '
'[-5.1031494140625000, '
'8.1299292850467957]]]}'),
project=self.prj,
type='MI',
attributes={})
ResourceFactory.create(content_object=su, project=self.prj)
party = PartyFactory.create(project=test_objs['projects'][1])
tenure = TenureRelationshipFactory.create(
project=self.prj,
party=party,
spatial_unit=su,
tenure_type=TenureRelationshipType.objects.create(
id='CR', label='Customary Rights'))
ResourceFactory.create(content_object=su, project=self.prj)
ResourceFactory.create(content_object=party, project=self.prj)
ResourceFactory.create(content_object=tenure, project=self.prj)
def test_get_all_download(self):
ensure_dirs()
data = {'type': 'all'}
user = UserFactory.create()
project = ProjectFactory.create()
res = ResourceFactory.create(project=project)
form = forms.DownloadForm(project, user, data=data)
assert form.is_valid() is True
path, mime = form.get_file()
assert '{}-{}'.format(project.id, user.id) in path
assert mime == 'application/zip'
with ZipFile(path, 'r') as testzip:
assert len(testzip.namelist()) == 4
assert res.original_file in testzip.namelist()
assert 'resources.xlsx' in testzip.namelist()
assert 'data.xlsx' in testzip.namelist()
assert 'data-shp.zip' in testzip.namelist()
def test_get_all_download(self):
ensure_dirs()
data = {'type': 'all'}
user = UserFactory.create()
project = ProjectFactory.create()
geometry = 'SRID=4326;POINT (30 10)'
SpatialUnitFactory.create(project=project, geometry=geometry)
res = ResourceFactory.create(project=project)
form = forms.DownloadForm(project, user, data=data)
assert form.is_valid() is True
path, mime = form.get_file()
assert '{}-{}'.format(project.id, user.id) in path
assert mime == 'application/zip'
with ZipFile(path, 'r') as testzip:
assert len(testzip.namelist()) == 4
assert res.original_file in testzip.namelist()
assert 'resources.xlsx' in testzip.namelist()
assert 'data.xlsx' in testzip.namelist()
assert 'data-shp.zip' in testzip.namelist()
def test_get_all_download(self):
ensure_dirs()
data = {"type": "all"}
user = UserFactory.create()
project = ProjectFactory.create()
geometry = "SRID=4326;POINT (30 10)"
SpatialUnitFactory.create(project=project, geometry=geometry)
res = ResourceFactory.create(project=project)
form = forms.DownloadForm(project, user, data=data)
assert form.is_valid() is True
path, mime = form.get_file()
assert "{}-{}".format(project.id, user.id) in path
assert mime == "application/zip"
with ZipFile(path, "r") as testzip:
assert len(testzip.namelist()) == 4
assert res.original_file in testzip.namelist()
assert "resources.xlsx" in testzip.namelist()
assert "data.xlsx" in testzip.namelist()
assert "data-shp.zip" in testzip.namelist()
def test_pack_resource_data(self):
project = ProjectFactory.create()
exporter = ResourceExporter(project)
res = ResourceFactory.create(project=project)
loc = SpatialUnitFactory.create(project=project)
loc2 = SpatialUnitFactory.create(project=project)
par = PartyFactory.create(project=project)
rel = TenureRelationshipFactory.create(project=project)
ContentObject.objects.create(resource=res, content_object=loc)
ContentObject.objects.create(resource=res, content_object=loc2)
ContentObject.objects.create(resource=res, content_object=par)
ContentObject.objects.create(resource=res, content_object=rel)
packed = exporter.pack_resource_data(res)
assert packed[0] == res.id
assert packed[1] == res.name
assert packed[2] == res.description
assert packed[3] == res.original_file
assert loc.id in packed[4]
assert loc2.id in packed[4]
assert par.id in packed[5]
assert rel.id in packed[6]
def test_pack_resource_data(self):
project = ProjectFactory.create()
exporter = ResourceExporter(project)
res = ResourceFactory.create(project=project)
loc = SpatialUnitFactory.create(project=project)
loc2 = SpatialUnitFactory.create(project=project)
par = PartyFactory.create(project=project)
rel = TenureRelationshipFactory.create(project=project)
ContentObject.objects.create(resource=res, content_object=loc)
ContentObject.objects.create(resource=res, content_object=loc2)
ContentObject.objects.create(resource=res, content_object=par)
ContentObject.objects.create(resource=res, content_object=rel)
packed = exporter.pack_resource_data(res)
assert packed[0] == res.id
assert packed[1] == res.name
assert packed[2] == res.description
assert packed[3] == res.original_file
assert loc.id in packed[4]
assert loc2.id in packed[4]
assert par.id in packed[5]
assert rel.id in packed[6]
def test_make_download(self):
res = ResourceFactory.create(project=self.project)
loc1 = SpatialUnitFactory.create(project=self.project)
loc2 = SpatialUnitFactory.create(project=self.project)
par = PartyFactory.create(project=self.project)
rel = TenureRelationshipFactory.create(project=self.project)
ContentObject.objects.create(resource=res, content_object=loc1)
ContentObject.objects.create(resource=res, content_object=loc2)
ContentObject.objects.create(resource=res, content_object=par)
ContentObject.objects.create(resource=res, content_object=rel)
ensure_dirs()
original_es_dump_path = os.path.join(
os.path.dirname(settings.BASE_DIR),
'search/tests/files/test_es_dump_basic.esjson')
es_dump_path = os.path.join(test_dir, 'test-res1-orig.esjson')
shutil.copy(original_es_dump_path, es_dump_path)
# Rewrite the ES dump file to inject the resource ID
with open(es_dump_path, 'r') as infile:
es_dump_path = os.path.join(test_dir, 'test-res1.esjson')
fwrite = open(es_dump_path, 'w')
for line in infile:
fwrite.write(line.replace('ID3', res.id))
fwrite.close()
exporter = ResourceExporter(self.project)
zip_path, mime_type = exporter.make_download(es_dump_path)
assert zip_path == os.path.join(test_dir, 'test-res1-res.zip')
assert mime_type == ('application/zip')
with ZipFile(zip_path) as myzip:
files = myzip.namelist()
assert len(files) == 2
assert 'resources.xlsx' in files
assert 'resources/baby_goat.jpeg' in files
myzip.extract('resources.xlsx', test_dir)
wb = load_workbook(os.path.join(test_dir, 'resources.xlsx'))
assert wb.get_sheet_names() == ['resources']
ws = wb['resources']
assert ws['A1'].value == 'id'
assert ws['B1'].value == 'name'
assert ws['C1'].value == 'description'
assert ws['D1'].value == 'filename'
assert ws['E1'].value == 'locations'
assert ws['F1'].value == 'parties'
assert ws['G1'].value == 'relationships'
assert ws['A2'].value == res.id
assert ws['B2'].value == "Goat"
assert ws['C2'].value == "Let's pretend there's a description."
assert ws['D2'].value == "baby_goat.jpeg"
ids = ws['E2'].value.split(',')
assert len(ids) == 2
assert loc1.id in ids
assert loc2.id in ids
assert ws['F2'].value == par.id
assert ws['G2'].value == rel.id
def setup_models(self):
self.project = ProjectFactory.create()
self.party = PartyFactory.create(project=self.project)
self.attached = ResourceFactory.create(project=self.project,
content_object=self.party)
self.unattached = ResourceFactory.create(project=self.project)
def setup_models(self):
self.project = ProjectFactory.create()
self.location = SpatialUnitFactory.create(project=self.project)
self.attached = ResourceFactory.create(project=self.project,
content_object=self.location)
self.unattached = ResourceFactory.create(project=self.project)
def setup_data(self):
self.project = ProjectFactory.create()
QuestionnaireFactory.create(project=self.project)
content_type = ContentType.objects.get(app_label='spatial',
model='spatialunit')
create_attrs_schema(
project=self.project,
dict=attr_schemas.location_xform_group,
content_type=content_type,
)
content_type = ContentType.objects.get(app_label='party',
model='party')
create_attrs_schema(
project=self.project,
dict=attr_schemas.default_party_xform_group,
content_type=content_type,
)
create_attrs_schema(
project=self.project,
dict=attr_schemas.individual_party_xform_group,
content_type=content_type,
)
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
create_attrs_schema(
project=self.project,
dict=attr_schemas.tenure_relationship_xform_group,
content_type=content_type,
)
self.location = SpatialUnitFactory.create(
project=self.project,
geometry='SRID=4326;POINT(1 1)',
attributes={
'quality': 'point',
'infrastructure': 'food',
},
)
self.party = PartyFactory.create(
project=self.project,
type='IN',
attributes={
'gender': 'm',
'homeowner': 'yes',
'dob': '1951-05-05'
},
)
self.tenure_rel = TenureRelationshipFactory.create(
project=self.project,
spatial_unit=self.location,
party=self.party,
attributes={'notes': 'The best relationship!'},
)
self.resource = ResourceFactory.create(project=self.project)
self.location_raw_result = {
'id': self.location.id,
'type': self.location.type,
'geometry': {
'type': 'geometry',
'value': '0101000020E6100000000000000000F03F000000000000F03F',
},
'attributes': {
'type': 'jsonb',
'value': '{"infrastructure": "food", "quality": "point"}',
},
'@timestamp': '2017-01-01T01:23:45.678Z',
}
self.party_raw_result = {
'id': self.party.id,
'name': self.party.name,
'type': 'IN',
'attributes': {
'type':
'jsonb',
'value': ('{"dob": "1951-05-05",'
' "gender": "m",'
' "homeowner": "yes"}'),
},
'tenure_id': None,
'tenure_attributes': None,
'tenure_partyid': None,
'spatial_unit_id': None,
'tenure_type_id': None,
'@timestamp': '2017-01-01T01:23:45.678Z',
}
self.tenure_rel_raw_result = {
'id': self.party.id,
'name': self.party.name,
'type': 'IN',
'attributes': {
'type':
'jsonb',
'value': ('{"dob": "1951-05-05",'
' "gender": "m",'
' "homeowner": "yes"}'),
},
'tenure_id': self.tenure_rel.id,
'tenure_attributes': {
'type': 'jsonb',
'value': '{"notes": "The best relationship!"}',
},
'tenure_partyid': self.party.id,
'spatial_unit_id': self.location.id,
'tenure_type_id': self.tenure_rel.tenure_type.id,
'@timestamp': '2017-01-01T01:23:45.678Z',
}
self.resource_raw_result = {
'id': self.resource.id,
'name': self.resource.name,
'description': self.resource.description,
'file': 'http://*****:*****@timestamp': '2017-01-01T01:23:45.678Z',
}
def setup_models(self):
self.project = ProjectFactory.create()
self.party = PartyFactory.create(project=self.project)
self.attached = ResourceFactory.create(project=self.project,
content_object=self.party)
self.unattached = ResourceFactory.create(project=self.project)
def setup_models(self):
self.project = ProjectFactory.create()
self.location = SpatialUnitFactory.create(project=self.project)
self.attached = ResourceFactory.create(project=self.project,
content_object=self.location)
self.unattached = ResourceFactory.create(project=self.project)
def setup_models(self):
self.user = UserFactory.create()
assign_policies(self.user)
self.project = ProjectFactory.create(slug='test-project')
QuestionnaireFactory.create(project=self.project)
content_type = ContentType.objects.get(app_label='party',
model='party')
create_attrs_schema(
project=self.project,
dict=attr_schemas.individual_party_xform_group,
content_type=content_type,
)
create_attrs_schema(
project=self.project,
dict=attr_schemas.default_party_xform_group,
content_type=content_type,
)
content_type = ContentType.objects.get(app_label='party',
model='tenurerelationship')
create_attrs_schema(
project=self.project,
dict=attr_schemas.tenure_relationship_xform_group,
content_type=content_type,
)
self.su = SpatialUnitFactory.create(project=self.project, type='CB')
self.party = PartyFactory.create(project=self.project,
type='IN',
attributes={
'gender': 'm',
'homeowner': 'yes',
'dob': '1951-05-05'
})
self.tenure_rel = TenureRelationshipFactory.create(
spatial_unit=self.su,
party=self.party,
project=self.project,
attributes={'notes': 'PBS is the best.'})
self.resource = ResourceFactory.create(project=self.project)
self.results = get_fake_es_api_results(self.project, self.su,
self.party, self.tenure_rel,
self.resource)
self.proj_result = self.results['hits']['hits'][0]
self.su_result = self.results['hits']['hits'][1]
self.party_result = self.results['hits']['hits'][2]
self.tenure_rel_result = self.results['hits']['hits'][3]
self.resource_result = self.results['hits']['hits'][4]
self.query = 'searching'
self.query_body = {
'query': parse_query(self.query),
'from': 10,
'size': 20,
'sort': {
'_score': {
'order': 'desc'
}
},
}
url = '{}/project-{}/spatial,party,resource/_search/'
self.es_endpoint = url.format(api_url, self.project.id)
self.es_body = json.dumps(self.query_body, sort_keys=True)
def test_get_most_liked_resource(self):
resource = ResourceFactory.create(
likes=[self.user, UserFactory.create()],
status=RESOURCE_APPROVED,
)
self.assertEqual(self.user.get_most_liked_resource().id, resource.id)
def test_make_download(self):
res = ResourceFactory.create(project=self.project)
loc1 = SpatialUnitFactory.create(project=self.project)
loc2 = SpatialUnitFactory.create(project=self.project)
par = PartyFactory.create(project=self.project)
rel = TenureRelationshipFactory.create(project=self.project)
ContentObject.objects.create(resource=res, content_object=loc1)
ContentObject.objects.create(resource=res, content_object=loc2)
ContentObject.objects.create(resource=res, content_object=par)
ContentObject.objects.create(resource=res, content_object=rel)
ensure_dirs()
original_es_dump_path = os.path.join(
os.path.dirname(settings.BASE_DIR),
'search/tests/files/test_es_dump_basic.esjson')
es_dump_path = os.path.join(test_dir, 'test-all1-orig.esjson')
shutil.copy(original_es_dump_path, es_dump_path)
# Rewrite the ES dump file to inject the resource ID
with open(es_dump_path, 'r') as infile:
es_dump_path = os.path.join(test_dir, 'test-all1.esjson')
fwrite = open(es_dump_path, 'w')
for line in infile:
fwrite.write(line.replace('ID3', res.id))
fwrite.close()
exporter = AllExporter(self.project)
zip_path, mime_type = exporter.make_download(es_dump_path)
assert zip_path == os.path.join(test_dir, 'test-all1-res.zip')
assert mime_type == ('application/zip')
with ZipFile(zip_path) as myzip:
files = myzip.namelist()
assert len(files) == 8
assert 'data.xlsx' in files
assert 'resources.xlsx' in files
assert 'resources/baby_goat.jpeg' in files
assert 'shape_files/README.txt' in files
assert 'shape_files/point.dbf' in files
assert 'shape_files/point.prj' in files
assert 'shape_files/point.shp' in files
assert 'shape_files/point.shx' in files
myzip.extract('resources.xlsx', test_dir)
wb = load_workbook(os.path.join(test_dir, 'resources.xlsx'))
assert wb.get_sheet_names() == ['resources']
ws = wb['resources']
assert ws['A1'].value == 'id'
assert ws['B1'].value == 'name'
assert ws['C1'].value == 'description'
assert ws['D1'].value == 'filename'
assert ws['E1'].value == 'locations'
assert ws['F1'].value == 'parties'
assert ws['G1'].value == 'relationships'
assert ws['A2'].value == res.id
assert ws['B2'].value == "Goat"
assert ws['C2'].value == "Let's pretend there's a description."
assert ws['D2'].value == "baby_goat.jpeg"
ids = ws['E2'].value.split(',')
assert len(ids) == 2
assert loc1.id in ids
assert loc2.id in ids
assert ws['F2'].value == par.id
assert ws['G2'].value == rel.id
myzip.extract('data.xlsx', test_dir)
wb = load_workbook(os.path.join(test_dir, 'data.xlsx'))
assert wb.get_sheet_names() == [
'locations', 'parties', 'relationships'
]
ws = wb['locations']
assert ws['A1'].value == 'id'
assert ws['B1'].value == 'geometry.ewkt'
assert ws['C1'].value == 'type'
assert ws['D1'].value == 'quality'
assert ws['E1'].value == 'infrastructure'
assert ws['A2'].value == 'ID0'
assert ws['B2'].value == 'SRID=4326;POINT (1 1)'
assert ws['C2'].value == 'PA'
assert ws['D2'].value == 'point'
assert ws['E2'].value == 'food, electricity'
ws = wb['parties']
assert ws['A1'].value == 'id'
assert ws['B1'].value == 'name'
assert ws['C1'].value == 'type'
assert ws['D1'].value == 'notes'
assert ws['E1'].value == 'gender'
assert ws['F1'].value == 'homeowner'
assert ws['G1'].value == 'dob'
assert ws['H1'].value == 'number_of_members'
assert ws['I1'].value == 'date_formed'
assert ws['A2'].value == 'ID1'
assert ws['B2'].value == "Cadastanaut"
assert ws['C2'].value == 'IN'
assert ws['D2'].value is None
assert ws['E2'].value == 'm'
assert ws['F2'].value == 'yes'
assert ws['G2'].value == '1951-05-05'
assert ws['H2'].value is None
assert ws['I2'].value is None
ws = wb['relationships']
assert ws['A1'].value == 'id'
assert ws['B1'].value == 'party_id'
assert ws['C1'].value == 'spatial_unit_id'
assert ws['D1'].value == 'tenure_type_id'
assert ws['E1'].value == 'notes'
assert ws['A2'].value == 'ID2'
assert ws['B2'].value == 'ID1'
assert ws['C2'].value == 'ID0'
assert ws['D2'].value == 'CU'
assert ws['E2'].value == "The best relationship!"
def setUp(self):
self.resource = ResourceFactory.create(status=RESOURCE_APPROVED)
self.superuser = UserFactory.create(password='******')
