class AssetsDeleteEndpointTestCase(StacBaseTestCase):
@mock_s3_asset_file
def setUp(self): # pylint: disable=invalid-name
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.item = self.factory.create_item_sample(
collection=self.collection).model
self.asset = self.factory.create_asset_sample(item=self.item).model
self.client = Client()
client_login(self.client)
self.maxDiff = None # pylint: disable=invalid-name
def test_asset_endpoint_delete_asset(self):
collection_name = self.collection.name
item_name = self.item.name
asset_name = self.asset.name
path = f'/{STAC_BASE_V}/collections/{collection_name}/items/{item_name}/assets/{asset_name}'
response = self.client.delete(path)
self.assertStatusCode(200, response)
# Check that is has really been deleted
response = self.client.get(path)
self.assertStatusCode(404, response)
# Check that it is really not to be found in DB
self.assertFalse(Asset.objects.filter(name=self.asset.name).exists(),
msg="Deleted asset still found in DB")
def test_asset_endpoint_delete_asset_invalid_name(self):
collection_name = self.collection.name
item_name = self.item.name
path = (f"/{STAC_BASE_V}/collections/{collection_name}"
f"/items/{item_name}/assets/non-existent-asset")
response = self.client.delete(path)
self.assertStatusCode(404, response)
def setUp(self): # pylint: disable=invalid-name
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.item = self.factory.create_item_sample(
collection=self.collection).model
self.asset = self.factory.create_asset_sample(item=self.item).model
self.client = Client()
def setUp(self): # pylint: disable=invalid-name
self.client = Client()
client_login(self.client)
self.factory = Factory()
self.collection = self.factory.create_collection_sample(db_create=True)
self.item = self.factory.create_item_sample(self.collection.model, db_create=True)
self.maxDiff = None # pylint: disable=invalid-name
def setUp(self):
self.client = Client()
client_login(self.client)
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.items = self.factory.create_item_samples(
['item-switzerland-west'], self.collection, db_create=True)
def setUp(self):
self.factory = Factory()
self.collection = self.factory.create_collection_sample(
db_create=True).model
self.item = self.factory.create_item_sample(collection=self.collection,
db_create=True).model
self.asset = self.factory.create_asset_sample(item=self.item,
db_create=True)
def setUp(self):
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.item = self.factory.create_item_sample(
collection=self.collection,
name='base-bbox',
geometry=GEOSGeometry(
'SRID=4326;POLYGON ((0 0, 0 45, 45 45, 45 0, 0 0))')).model
def setUp(self): # pylint: disable=invalid-name
self.client = Client()
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.item = self.factory.create_item_sample(
collection=self.collection).model
self.asset_1 = self.factory.create_asset_sample(item=self.item,
db_create=True)
self.maxDiff = None # pylint: disable=invalid-name
def setUp(self):
self.username = '******'
self.password = '******'
get_user_model().objects.create_superuser(self.username,
password=self.password)
self.factory = Factory()
self.collection_sample = self.factory.create_collection_sample(
sample='collection-2', db_create=True)
self.item_sample = self.factory.create_item_sample(
self.collection_sample.model, sample='item-2', db_create=True)
def setUp(self): # pylint: disable=invalid-name
self.client = Client()
client_login(self.client)
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.item = self.factory.create_item_sample(
collection=self.collection).model
self.asset = self.factory.create_asset_sample(
item=self.item, sample='asset-no-file').model
self.maxDiff = None # pylint: disable=invalid-name
class AssetsWriteEndpointAssetFileTestCase(StacBaseTestCase):
@mock_s3_asset_file
def setUp(self): # pylint: disable=invalid-name
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.item = self.factory.create_item_sample(
collection=self.collection).model
self.client = Client()
client_login(self.client)
self.maxDiff = None # pylint: disable=invalid-name
class AssetRaceConditionTest(StacBaseTransactionTestCase):
def setUp(self):
self.username = '******'
self.password = '******'
get_user_model().objects.create_superuser(self.username,
password=self.password)
self.factory = Factory()
self.collection_sample = self.factory.create_collection_sample(
sample='collection-2', db_create=True)
self.item_sample = self.factory.create_item_sample(
self.collection_sample.model, sample='item-2', db_create=True)
def test_asset_upsert_race_condition(self):
workers = 5
status_201 = 0
asset_sample = self.factory.create_asset_sample(
self.item_sample.model,
sample='asset-no-checksum',
)
def asset_atomic_upsert_test(worker):
# This method run on separate thread therefore it requires to create a new client and
# to login it for each call.
client = Client()
client.login(username=self.username, password=self.password)
return client.put(reverse('asset-detail',
args=[
self.collection_sample['name'],
self.item_sample['name'],
asset_sample['name']
]),
data=asset_sample.get_json('put'),
content_type='application/json')
# We call the PUT asset several times in parallel with the same data to make sure
# that we don't have any race condition.
responses, errors = self.run_parallel(workers,
asset_atomic_upsert_test)
for worker, response in responses:
if response.status_code == 201:
status_201 += 1
self.assertIn(
response.status_code, [200, 201],
msg=
f'Unexpected response status code {response.status_code} for worker {worker}'
)
self.check_stac_asset(asset_sample.json,
response.json(),
self.collection_sample['name'],
self.item_sample['name'],
ignore=['item'])
self.assertEqual(status_201,
1,
msg="Not only one upsert did a create !")
class AssetsEndpointUnauthorizedTestCase(StacBaseTestCase):
@mock_s3_asset_file
def setUp(self): # pylint: disable=invalid-name
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.item = self.factory.create_item_sample(
collection=self.collection).model
self.asset = self.factory.create_asset_sample(item=self.item).model
self.client = Client()
def test_unauthorized_asset_post_put_patch_delete(self):
collection_name = self.collection.name
item_name = self.item.name
asset_name = self.asset.name
new_asset = self.factory.create_asset_sample(item=self.item).json
updated_asset = self.factory.create_asset_sample(
item=self.item, name=asset_name,
sample='asset-1-updated').get_json('post')
# make sure POST fails for anonymous user:
path = f'/{STAC_BASE_V}/collections/{collection_name}/items/{item_name}/assets'
response = self.client.post(path,
data=new_asset,
content_type="application/json")
self.assertStatusCode(401,
response,
msg="Unauthorized post was permitted.")
# make sure PUT fails for anonymous user:
path = f'/{STAC_BASE_V}/collections/{collection_name}/items/{item_name}/assets/{asset_name}'
response = self.client.put(path,
data=updated_asset,
content_type="application/json")
self.assertStatusCode(401,
response,
msg="Unauthorized put was permitted.")
# make sure PATCH fails for anonymous user:
path = f'/{STAC_BASE_V}/collections/{collection_name}/items/{item_name}/assets/{asset_name}'
response = self.client.patch(path,
data=updated_asset,
content_type="application/json")
self.assertStatusCode(401,
response,
msg="Unauthorized patch was permitted.")
# make sure DELETE fails for anonymous user:
path = f'/{STAC_BASE_V}/collections/{collection_name}/items/{item_name}/assets/{asset_name}'
response = self.client.delete(path)
self.assertStatusCode(401,
response,
msg="Unauthorized del was permitted.")
def setUp(self):
self.data_factory = Factory()
self.collection_created = utc_aware(datetime.now())
self.collection = self.data_factory.create_collection_sample(
db_create=True)
self.item = self.data_factory.create_item_sample(
collection=self.collection.model, db_create=True)
self.asset = self.data_factory.create_asset_sample(
item=self.item.model, db_create=True)
self.collection.model.refresh_from_db()
self.maxDiff = None # pylint: disable=invalid-name
def setUpTestData(cls):
cls.factory = Factory()
cls.collection = cls.factory.create_collection_sample().model
cls.item_1 = cls.factory.create_item_sample(
cls.collection,
name='item-1',
properties_datetime=fromisoformat('2019-01-01T00:00:00Z'),
db_create=True,
)
cls.now = utc_aware(datetime.utcnow())
cls.yesterday = cls.now - timedelta(days=1)
cls.item_now = cls.factory.create_item_sample(
cls.collection,
name='item-now',
properties_datetime=cls.now,
db_create=True,
)
cls.item_yesterday = cls.factory.create_item_sample(
cls.collection,
name='item-yesterday',
properties_datetime=cls.yesterday,
db_create=True)
def setUpTestData(cls):
cls.factory = Factory()
cls.collection = cls.factory.create_collection_sample().model
cls.item = cls.factory.create_item_sample(
collection=cls.collection).model
cls.asset_1 = cls.factory.create_asset_sample(item=cls.item).model
cls.asset_2 = cls.factory.create_asset_sample(item=cls.item).model
def setUp(self):
self.factory = Factory()
self.collection = self.factory.create_collection_sample(
name='collection-1',
db_create=True,
)
self.item = self.factory.create_item_sample(
collection=self.collection.model,
name='item-1',
db_create=True,
)
self.asset = self.factory.create_asset_sample(
item=self.item.model,
name='asset-1.tiff',
db_create=True,
)
class AssetsUpdateEndpointAssetFileTestCase(StacBaseTestCase):
@mock_s3_asset_file
def setUp(self): # pylint: disable=invalid-name
self.factory = Factory()
self.collection = self.factory.create_collection_sample(db_create=True)
self.item = self.factory.create_item_sample(
collection=self.collection.model, db_create=True)
self.asset = self.factory.create_asset_sample(item=self.item.model,
db_create=True)
self.client = Client()
client_login(self.client)
self.maxDiff = None # pylint: disable=invalid-name
def test_asset_endpoint_patch_put_href(self):
collection_name = self.collection['name']
item_name = self.item['name']
asset_name = self.asset['name']
asset_sample = self.asset.copy()
put_payload = asset_sample.get_json('put')
put_payload['href'] = 'https://testserver/non-existing-asset'
patch_payload = {'href': 'https://testserver/non-existing-asset'}
path = f'/{STAC_BASE_V}/collections/{collection_name}/items/{item_name}/assets/{asset_name}'
response = self.client.patch(path,
data=patch_payload,
content_type="application/json")
self.assertStatusCode(400, response)
description = response.json()['description']
self.assertIn('href',
description,
msg=f'Unexpected field error {description}')
self.assertEqual("Found read-only property in payload",
description['href'][0],
msg="Unexpected error message")
response = self.client.put(path,
data=put_payload,
content_type="application/json")
self.assertStatusCode(400, response)
description = response.json()['description']
self.assertIn('href',
description,
msg=f'Unexpected field error {description}')
self.assertEqual("Found read-only property in payload",
description['href'][0],
msg="Unexpected error message")
def setUpTestData(cls):
cls.data_factory = Factory()
cls.collection = cls.data_factory.create_collection_sample(
db_create=True)
cls.item = cls.data_factory.create_item_sample(
collection=cls.collection.model, db_create=True)
cls.asset = cls.data_factory.create_asset_sample(item=cls.item.model,
db_create=True)
def setUpTestData(cls): # pylint: disable=invalid-name
cls.data_factory = Factory()
cls.collection = cls.data_factory.create_collection_sample(
db_create=True)
cls.item = cls.data_factory.create_item_sample(
collection=cls.collection.model, db_create=True)
cls.asset = cls.data_factory.create_asset_sample(item=cls.item.model,
db_create=True)
def setUp(self):
self.factory = Factory()
self.password = '******'
self.username = '******'
self.admin_user = get_user_model().objects.create_superuser(
self.username, '*****@*****.**', self.password)
self.client = Client()
self.collection = None
self.item = None
class CollectionsDeleteEndpointTestCase(StacBaseTestCase):
def setUp(self): # pylint: disable=invalid-name
self.client = Client()
client_login(self.client)
self.factory = Factory()
self.collection = self.factory.create_collection_sample(db_create=True)
self.item = self.factory.create_item_sample(self.collection.model, db_create=True)
self.maxDiff = None # pylint: disable=invalid-name
def test_authorized_collection_delete(self):
path = reverse('collection-detail', args=[self.collection["name"]])
response = self.client.delete(path)
self.assertStatusCode(400, response)
self.assertEqual(
response.json()['description'], ['Deleting Collection with items not allowed']
)
# delete first the item
item_path = reverse('item-detail', args=[self.collection["name"], self.item['name']])
response = self.client.delete(item_path)
self.assertStatusCode(200, response)
# try the collection delete again
response = self.client.delete(path)
self.assertStatusCode(200, response)
# Check that the object doesn't exists anymore
self.assertFalse(
CollectionLink.objects.filter(collection__name=self.collection["name"]).exists(),
msg="Deleted collection link still in DB"
)
self.assertFalse(
Provider.objects.filter(collection__name=self.collection["name"]).exists(),
msg="Deleted provider still in DB"
)
self.assertFalse(
Collection.objects.filter(name=self.collection["name"]).exists(),
msg="Deleted collection still in DB"
)
class OneItemSpatialTestCase(StacBaseTestCase):
def setUp(self):
self.client = Client()
client_login(self.client)
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.items = self.factory.create_item_samples(
['item-switzerland-west'], self.collection, db_create=True)
def test_single_item(self):
collection_name = self.collection.name
item_name = self.items[0].model.name
response_item = self.client.get(
f"/{STAC_BASE_V}/collections/{collection_name}/items/{item_name}")
response_item_json = response_item.json()
response_collection = self.client.get(
f"/{STAC_BASE_V}/collections/{collection_name}")
response_collection_json = response_collection.json()
bbox_collection = response_collection_json['extent']['spatial'][
'bbox'][0]
bbox_items = response_item_json['bbox']
self.assertEqual(bbox_items, bbox_collection)
def test_no_items(self):
collection_name = self.collection.name
item_name = self.items[0].model.name
# delete the item
path = f'/{STAC_BASE_V}/collections/{self.collection.name}/items/{item_name}'
response = self.client.delete(path)
self.assertStatusCode(200, response)
response_collection = self.client.get(
f"/{STAC_BASE_V}/collections/{collection_name}")
response_collection_json = response_collection.json()
bbox_collection = response_collection_json['extent']['spatial'][
'bbox'][0]
self.assertEqual(bbox_collection, [])
def test_validate_asset_href_path(self):
factory = Factory()
collection = factory.create_collection_sample(
name='collection-test').model
item = factory.create_item_sample(collection=collection,
name='item-test').model
validate_asset_href_path(item, 'asset-test',
'collection-test/item-test/asset-test')
with self.settings(AWS_S3_CUSTOM_DOMAIN='new-domain'):
validate_asset_href_path(item, 'asset-test',
'collection-test/item-test/asset-test')
with self.settings(AWS_S3_CUSTOM_DOMAIN='new-domain/with-prefix/'):
validate_asset_href_path(
item, 'asset-test',
'with-prefix/collection-test/item-test/asset-test')
with self.settings(AWS_S3_CUSTOM_DOMAIN='//new-domain/with-prefix'):
validate_asset_href_path(
item, 'asset-test',
'with-prefix/collection-test/item-test/asset-test')
with self.settings(AWS_S3_CUSTOM_DOMAIN='//new domain/with-prefix'):
validate_asset_href_path(
item, 'asset-test',
'with-prefix/collection-test/item-test/asset-test')
with self.assertRaises(
serializers.ValidationError,
msg=
"Invalid Asset href path did not raises serializers.ValidationError"
):
validate_asset_href_path(item, 'asset-test', 'asset-test')
validate_asset_href_path(item, 'asset-test',
'item-test/asset-test')
validate_asset_href_path(item, 'asset-test',
'collection-test/item-test/asset-test')
validate_asset_href_path(
item, 'asset-test',
'/service-stac-local/collection-test/item-test/asset-test')
class AssetsUnimplementedEndpointTestCase(StacBaseTestCase):
@mock_s3_asset_file
def setUp(self): # pylint: disable=invalid-name
self.factory = Factory()
self.collection = self.factory.create_collection_sample().model
self.item = self.factory.create_item_sample(
collection=self.collection).model
self.client = Client()
client_login(self.client)
self.maxDiff = None # pylint: disable=invalid-name
def test_asset_unimplemented_post(self):
collection_name = self.collection.name
item_name = self.item.name
asset = self.factory.create_asset_sample(item=self.item,
required_only=True)
response = self.client.post(
f'/{STAC_BASE_V}/collections/{collection_name}/items/{item_name}/assets',
data=asset.get_json('post'),
content_type="application/json")
self.assertStatusCode(405, response)
def setUpTestData(cls):
cls.factory = Factory()
cls.collection = cls.factory.create_collection_sample().model
cls.items = cls.factory.create_item_samples(
[
'item-switzerland', 'item-switzerland-west',
'item-switzerland-east', 'item-switzerland-north',
'item-switzerland-south', 'item-paris'
],
cls.collection,
db_create=True,
)
def setUpTestData(cls):
cls.factory = Factory()
cls.collection = cls.factory.create_collection_sample(
name='collection-1',
db_create=True,
)
cls.item = cls.factory.create_item_sample(
collection=cls.collection.model,
name='item-1',
db_create=True,
)
cls.asset = cls.factory.create_asset_sample(
item=cls.item.model,
db_create=True,
)
def setUpTestData(cls):
cls.factory = Factory()
cls.collection = cls.factory.create_collection_sample().model
cls.items = cls.factory.create_item_samples(
[
'item-1', 'item-2', 'item-switzerland',
'item-switzerland-west', 'item-switzerland-east',
'item-switzerland-north', 'item-switzerland-south',
'item-paris'
],
cls.collection,
db_create=True,
)
cls.now = utc_aware(datetime.utcnow())
cls.yesterday = cls.now - timedelta(days=1)
class CollectionsUnImplementedEndpointTestCase(StacBaseTestCase):
def setUp(self): # pylint: disable=invalid-name
self.client = Client()
client_login(self.client)
self.factory = Factory()
self.collection = self.factory.create_collection_sample()
self.maxDiff = None # pylint: disable=invalid-name
def test_collections_post_unimplemented(self):
response = self.client.post(
f"/{STAC_BASE_V}/collections",
data=self.collection.get_json('post'),
content_type='application/json'
)
self.assertStatusCode(405, response)
def setUpTestData(cls):
cls.title_for_query = 'Item for pagination test'
cls.factory = Factory()
cls.collection = cls.factory.create_collection_sample().model
cls.items = cls.factory.create_item_samples(
[
'item-1', 'item-2', 'item-switzerland',
'item-switzerland-west', 'item-switzerland-east',
'item-switzerland-north', 'item-switzerland-south',
'item-paris'
],
cls.collection,
properties_title=[
'My item', cls.title_for_query, None, 'My item', 'My item',
cls.title_for_query, 'My item', cls.title_for_query
],
db_create=True,
)
def setUpTestData(cls):
cls.data_factory = Factory()
