def test_failure_fileserver_unauthenticated(self):
"""
Tests revoke download failure with the file server being unauthenticated
"""
models.Fileserver_Cluster_Member_Shard_Link.objects.all().delete()
url = reverse('fileserver_revoke_download')
ticket_decrypted = {
'hash_checksum': self.hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': self.file_transfer.id,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_size_transfered_exceeded(self):
"""
Tests authorize upload failure with a file transfer where the transfered bytes have already been used completely
"""
self.file_transfer.size_transferred = self.file_transfer.size
self.file_transfer.save()
url = reverse('fileserver_authorize_upload')
hash_checksum = 'ABC'
ticket_decrypted = {
'chunk_position': 1,
'hash_checksum': hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': self.file_transfer.id,
'chunk_size': self.file_size,
'hash_checksum': hash_checksum,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_nonauthorized_fileserver(self):
"""
Tests authorize upload failure with a fileserver that is not authorized
"""
models.Fileserver_Cluster_Member_Shard_Link.objects.all().delete()
url = reverse('fileserver_authorize_upload')
hash_checksum = 'ABC'
ticket_decrypted = {
'chunk_position': 1,
'hash_checksum': hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': self.file_transfer.id,
'chunk_size': self.file_size,
'hash_checksum': hash_checksum,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_mismatching_hash_checksums(self):
"""
Tests authorize upload failure with a hash checksum from the ticket that does not match the hash checksum that
the fileserver calculated
"""
url = reverse('fileserver_authorize_upload')
hash_checksum = 'ABC'
ticket_decrypted = {
'chunk_position': 1,
'hash_checksum': hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': self.file_transfer.id,
'chunk_size': self.file_size,
'hash_checksum': 'ABCD',
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_not_existing_file_transfer(self):
"""
Tests authorize upload failure with a file transfer that does not exist
"""
url = reverse('fileserver_authorize_upload')
hash_checksum = 'ABC'
ticket_decrypted = {
'chunk_position': 1,
'hash_checksum': hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': '76f4cc5a-b20d-494c-b922-81e7eaacea66',
'chunk_size': self.file_size,
'hash_checksum': hash_checksum,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_ticket_decryption_fail(self):
"""
Tests authorize upload failure with a token where the decryption fails
"""
url = reverse('fileserver_authorize_upload')
hash_checksum = 'ABC'
ticket_decrypted = {
'chunk_position': 1,
'hash_checksum': hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
self.file_transfer.secret_key = binascii.hexlify(
os.urandom(32)).decode()
self.file_transfer.save()
data = {
'file_transfer_id': self.file_transfer.id,
'chunk_size': self.file_size,
'hash_checksum': hash_checksum,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_chunk_size_limit_too_big(self):
"""
Tests authorize upload failure with a chunk_size_limit that is bigger than 128 * 1024 * 1024 + 40
"""
url = reverse('fileserver_authorize_upload')
hash_checksum = 'ABC'
ticket_decrypted = {
'chunk_position': 1,
'hash_checksum': hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': self.file_transfer.id,
'chunk_size': 128 * 1024 * 1024 + 40 + 1,
'hash_checksum': hash_checksum,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_file_transfer_not_being_a_download(self):
"""
Tests revoke download failure with the file transfer not having the type "download"
"""
self.file_transfer.type = 'upload'
self.file_transfer.save()
url = reverse('fileserver_revoke_download')
ticket_decrypted = {
'hash_checksum': self.hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': self.file_transfer.id,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_token_decryption_error(self):
"""
Tests revoke download failure with token that cannot be decrypted
"""
url = reverse('fileserver_revoke_download')
ticket_decrypted = {
'hash_checksum': self.hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
self.file_transfer.secret_key = binascii.hexlify(
os.urandom(32)).decode()
self.file_transfer.save()
data = {
'file_transfer_id': self.file_transfer.id,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_successful(self):
"""
Tests revoke download successful
"""
url = reverse('fileserver_revoke_download')
ticket_decrypted = {
'hash_checksum': self.hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
chunk_size = self.file_size
data = {
'file_transfer_id': self.file_transfer.id,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
refreshed_file_transfer = models.File_Transfer.objects.get(
pk=self.file_transfer.id)
self.assertEqual(self.file_transfer.size_transferred - chunk_size,
refreshed_file_transfer.size_transferred)
self.assertEqual(self.file_transfer.chunk_count_transferred - 1,
refreshed_file_transfer.chunk_count_transferred)
def test_failure_chunk_size_transfer_limit_reached(self):
"""
Tests failing authorize download when the size transfer limit has been reached
"""
self.file_transfer.size_transferred = self.file_transfer.size
self.file_transfer.save()
url = reverse('fileserver_authorize_download')
ticket_decrypted = {
'hash_checksum': self.hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key, json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': self.file_transfer.id,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_successful(self):
"""
Tests authorize upload successful
"""
url = reverse('fileserver_authorize_upload')
hash_checksum = 'ABC'
ticket_decrypted = {
'chunk_position': 1,
'hash_checksum': hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
chunk_size = self.file_size
data = {
'file_transfer_id': self.file_transfer.id,
'chunk_size': chunk_size,
'hash_checksum': hash_checksum,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertTrue('shard_id' in response.data)
self.assertEqual(str(response.data['shard_id']), str(self.shard1.id))
self.assertEqual(models.File_Chunk.objects.count(), 1)
refreshed_file_transfer = models.File_Transfer.objects.get(
pk=self.file_transfer.id)
self.assertEqual(self.file_transfer.size_transferred + chunk_size,
refreshed_file_transfer.size_transferred)
self.assertEqual(self.file_transfer.chunk_count_transferred + 1,
refreshed_file_transfer.chunk_count_transferred)
def test_failure_missing_file_transfer_id(self):
"""
Tests failing authorize download when the file_transfer_id parameter is not set
"""
url = reverse('fileserver_authorize_download')
ticket_decrypted = {
'hash_checksum': self.hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key, json.dumps(ticket_decrypted).encode())
data = {
# 'file_transfer_id': self.file_transfer.id,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_file_transfer_id_does_not_exist(self):
"""
Tests failing authorize download when the file transfer id does not exist
"""
url = reverse('fileserver_authorize_download')
ticket_decrypted = {
'hash_checksum': self.hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key, json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': '8beab082-c802-4622-b9c1-2dcbef4f188b',
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_chunk_with_hash_checksum_does_not_exist(self):
"""
Tests failing authorize download when the chunk with the requested hash checksum doesnt exist
"""
url = reverse('fileserver_authorize_download')
ticket_decrypted = {
'hash_checksum': 'abcdef',
}
ticket_encrypted = encrypt(self.file_transfer.secret_key, json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': self.file_transfer.id,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_chunk_hash_not_exists(self):
"""
Tests revoke download failure for a chunk (identified by its hash) that does not exist
"""
url = reverse('fileserver_revoke_download')
ticket_decrypted = {
'hash_checksum': 'abcdef',
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': self.file_transfer.id,
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_failure_file_transfer_id_not_exist(self):
"""
Tests revoke download failure with a not existing file transfer
"""
url = reverse('fileserver_revoke_download')
ticket_decrypted = {
'hash_checksum': self.hash_checksum,
}
ticket_encrypted = encrypt(self.file_transfer.secret_key,
json.dumps(ticket_decrypted).encode())
data = {
'file_transfer_id': '6e92cf15-f1ad-4047-a504-39ff2e2ef4f1',
'ip_address': '127.0.0.1',
'ticket': ticket_encrypted['text'].decode(),
'ticket_nonce': ticket_encrypted['nonce'].decode(),
}
self.client.force_authenticate(user=self.fileserver1)
response = self.client.put(url, data)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
