def test_shared_read_access_blob(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._create_block_blob() token = self.bs.generate_blob_shared_access_signature( self.container_name, blob_name, permission=BlobPermissions.READ, expiry=datetime.utcnow() + timedelta(hours=1), ) # Act url = self.bs.make_blob_url( self.container_name, blob_name, sas_token=token, ) response = requests.get(url) # Assert self.assertTrue(response.ok) self.assertEqual(self.byte_data, response.content)
def test_create_blob_from_stream_with_progress_chunked_upload_parallel( self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._get_blob_reference() data = self.get_random_bytes(LARGE_BLOB_SIZE) with open(FILE_PATH, 'wb') as stream: stream.write(data) # Act progress = [] def callback(current, total): progress.append((current, total)) blob_size = len(data) with open(FILE_PATH, 'rb') as stream: self.bs.create_blob_from_stream(self.container_name, blob_name, stream, blob_size, progress_callback=callback, max_connections=5) # Assert self.assertBlobEqual(self.container_name, blob_name, data[:blob_size]) self.assert_upload_progress(len(data), self.bs.MAX_PAGE_SIZE, progress)
def test_create_blob_from_stream_with_progress_chunked_upload_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._get_blob_reference() data = self.get_random_bytes(LARGE_BLOB_SIZE) with open(FILE_PATH, "wb") as stream: stream.write(data) # Act progress = [] def callback(current, total): progress.append((current, total)) blob_size = len(data) with open(FILE_PATH, "rb") as stream: self.bs.create_blob_from_stream( self.container_name, blob_name, stream, blob_size, progress_callback=callback, max_connections=5 ) # Assert self.assertBlobEqual(self.container_name, blob_name, data[:blob_size]) self.assert_upload_progress(len(data), self.bs.MAX_PAGE_SIZE, progress)
def test_sas_signed_identifier(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._create_block_blob() access_policy = AccessPolicy() access_policy.start = '2011-10-11' access_policy.expiry = '2018-10-12' access_policy.permission = BlobPermissions.READ identifiers = {'testid': access_policy} resp = self.bs.set_container_acl(self.container_name, identifiers) token = self.bs.generate_blob_shared_access_signature( self.container_name, blob_name, id='testid') # Act service = BlockBlobService( self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, request_session=requests.Session(), ) self._set_service_options(service, self.settings) result = service.get_blob_to_bytes(self.container_name, blob_name) # Assert self.assertEqual(self.byte_data, result.content)
def test_sas_delete(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange entity = self._insert_random_entity() token = self.ts.generate_table_shared_access_signature( self.table_name, TablePermissions.DELETE, datetime.utcnow() + timedelta(hours=1), ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) service.delete_entity(self.table_name, entity.PartitionKey, entity.RowKey) # Assert with self.assertRaises(AzureMissingResourceHttpError): self.ts.get_entity(self.table_name, entity.PartitionKey, entity.RowKey)
def test_shared_read_access_blob_with_content_query_params(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._create_block_blob() token = self.bs.generate_blob_shared_access_signature( self.container_name, blob_name, permission=BlobPermissions.READ, expiry=datetime.utcnow() + timedelta(hours=1), cache_control='no-cache', content_disposition='inline', content_encoding='utf-8', content_language='fr', content_type='text', ) url = self.bs.make_blob_url( self.container_name, blob_name, sas_token=token, ) # Act response = requests.get(url) # Assert self.assertEqual(self.byte_data, response.content) self.assertEqual(response.headers['cache-control'], 'no-cache') self.assertEqual(response.headers['content-disposition'], 'inline') self.assertEqual(response.headers['content-encoding'], 'utf-8') self.assertEqual(response.headers['content-language'], 'fr') self.assertEqual(response.headers['content-type'], 'text')
def test_sas_update(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange queue_name = self._create_queue() self.qs.put_message(queue_name, u'message1') token = self.qs.generate_queue_shared_access_signature( queue_name, QueuePermissions.UPDATE, datetime.utcnow() + timedelta(hours=1), ) result = self.qs.get_messages(queue_name) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) service.update_message( queue_name, result[0].id, result[0].pop_receipt, visibility_timeout=0, content=u'updatedmessage1', ) # Assert result = self.qs.get_messages(queue_name) self.assertEqual(u'updatedmessage1', result[0].content)
def test_sas_add_outside_range(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange token = self.ts.generate_table_shared_access_signature( self.table_name, TablePermissions.ADD, datetime.utcnow() + timedelta(hours=1), start_pk='test', start_rk='test1', end_pk='test', end_rk='test1', ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) with self.assertRaises(AzureHttpError): entity = self._create_random_entity_dict() service.insert_entity(self.table_name, entity)
def test_sas_process(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange queue_name = self._create_queue() self.qs.put_message(queue_name, u'message1') token = self.qs.generate_queue_shared_access_signature( queue_name, QueuePermissions.PROCESS, datetime.utcnow() + timedelta(hours=1), ) # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) result = service.get_messages(queue_name) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.id) self.assertEqual(u'message1', message.content)
def test_shared_access_container(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange container_name = self._create_container() blob_name = 'blob1' data = b'hello world' self.bs.create_blob_from_bytes(container_name, blob_name, data) token = self.bs.generate_container_shared_access_signature( container_name, expiry=datetime.utcnow() + timedelta(hours=1), permission=ContainerPermissions.READ, ) url = self.bs.make_blob_url( container_name, blob_name, sas_token=token, ) # Act response = requests.get(url) # Assert self.assertTrue(response.ok) self.assertEqual(data, response.content)
def test_account_sas(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange table_name = self._create_table() entity = {"PartitionKey": "test", "RowKey": "test1", "text": "hello"} self.ts.insert_entity(table_name, entity) entity["RowKey"] = "test2" self.ts.insert_entity(table_name, entity) token = self.ts.generate_account_shared_access_signature( ResourceTypes.OBJECT, AccountPermissions.READ, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=1), ) # Act service = TableService(account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token) self._set_service_options(service, self.settings) entities = list(service.query_entities(table_name)) # Assert self.assertEqual(len(entities), 2) self.assertEqual(entities[0].text, "hello") self.assertEqual(entities[1].text, "hello")
def test_sas_query(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange entity = self._insert_random_entity() token = self.ts.generate_table_shared_access_signature( self.table_name, TablePermissions.QUERY, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=1), ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) entities = list( self.ts.query_entities(self.table_name, filter="PartitionKey eq '{}'".format( entity['PartitionKey']))) # Assert self.assertEqual(len(entities), 1) self._assert_default_entity(entities[0])
def test_shared_access_share(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange file_name = 'file1' dir_name = 'dir1' data = b'hello world' share_name = self._create_share() self.fs.create_directory(share_name, dir_name) self.fs.create_file_from_bytes(share_name, dir_name, file_name, data) token = self.fs.generate_share_shared_access_signature( share_name, expiry=datetime.utcnow() + timedelta(hours=1), permission=SharePermissions.READ, ) url = self.fs.make_file_url( share_name, dir_name, file_name, sas_token=token, ) # Act response = requests.get(url) # Assert self.assertTrue(response.ok) self.assertEqual(data, response.content)
def test_sas_add(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange token = self.ts.generate_table_shared_access_signature( self.table_name, TablePermissions.ADD, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=1), ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) entity = self._create_random_entity_dict() service.insert_entity(self.table_name, entity) # Assert resp = self.ts.get_entity(self.table_name, entity['PartitionKey'], entity['RowKey']) self._assert_default_entity(resp)
def test_shared_access_container(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange container_name = self._create_container() blob_name = 'blob1' data = b'hello world' self.bs.create_blob_from_bytes (container_name, blob_name, data) token = self.bs.generate_container_shared_access_signature( container_name, expiry=datetime.utcnow() + timedelta(hours=1), permission=ContainerPermissions.READ, ) url = self.bs.make_blob_url( container_name, blob_name, sas_token=token, ) # Act response = requests.get(url) # Assert self.assertTrue(response.ok) self.assertEqual(data, response.content)
def test_shared_delete_access_blob(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._create_block_blob() token = self.bs.generate_blob_shared_access_signature( self.container_name, blob_name, permission=BlobPermissions.DELETE, expiry=datetime.utcnow() + timedelta(hours=1), ) url = self.bs.make_blob_url( self.container_name, blob_name, sas_token=token, ) # Act response = requests.delete(url) # Assert self.assertTrue(response.ok) with self.assertRaises(AzureMissingResourceHttpError): blob = self.bs.get_blob_to_bytes(self.container_name, blob_name)
def test_generate_account_sas(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange token = self.account.generate_shared_access_signature( Services.BLOB, ResourceTypes.OBJECT, AccountPermissions.READ, datetime.utcnow() + timedelta(hours=1), ) service = self.account.create_block_blob_service() data = b'shared access signature with read permission on blob' container_name='container1' blob_name = 'blob1.txt' try: service.create_container(container_name) service.create_blob_from_bytes(container_name, blob_name, data) # Act url = service.make_blob_url( container_name, blob_name, sas_token=token, ) response = requests.get(url) # Assert self.assertTrue(response.ok) self.assertEqual(data, response.content) finally: service.delete_container(container_name)
def test_sas_signed_identifier(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange entity = self._insert_random_entity() access_policy = AccessPolicy() access_policy.start = '2011-10-11' access_policy.expiry = '2018-10-12' access_policy.permission = TablePermissions.QUERY identifiers = {'testid': access_policy} entities = self.ts.set_table_acl(self.table_name, identifiers) token = self.ts.generate_table_shared_access_signature( self.table_name, id='testid', ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) entities = list( self.ts.query_entities(self.table_name, filter="PartitionKey eq '{}'".format( entity.PartitionKey))) # Assert self.assertEqual(len(entities), 1) self._assert_default_entity(entities[0])
def test_sas_query(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange entity = self._insert_random_entity() token = self.ts.generate_table_shared_access_signature( self.table_name, TablePermissions.QUERY, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=1), ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) entities = list(self.ts.query_entities(self.table_name, filter="PartitionKey eq '{}'".format(entity['PartitionKey']))) # Assert self.assertEqual(len(entities), 1) self._assert_default_entity(entities[0])
def test_shared_write_access_blob(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange updated_data = b'updated blob data' blob_name = self._create_block_blob() token = self.bs.generate_blob_shared_access_signature( self.container_name, blob_name, permission=BlobPermissions.WRITE, expiry=datetime.utcnow() + timedelta(hours=1), ) url = self.bs.make_blob_url( self.container_name, blob_name, sas_token=token, ) # Act headers = {'x-ms-blob-type': self.bs.blob_type} response = requests.put(url, headers=headers, data=updated_data) # Assert self.assertTrue(response.ok) blob = self.bs.get_blob_to_bytes(self.container_name, blob_name) self.assertEqual(updated_data, blob.content)
def test_sas_add_inside_range(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange token = self.ts.generate_table_shared_access_signature( self.table_name, TablePermissions.ADD, datetime.utcnow() + timedelta(hours=1), start_pk='test', start_rk='test1', end_pk='test', end_rk='test1', ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) entity = self._create_random_entity_dict('test', 'test1') service.insert_entity(self.table_name, entity) # Assert resp = self.ts.get_entity(self.table_name, 'test', 'test1') self._assert_default_entity(resp)
def test_sas_update(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange entity = self._insert_random_entity() token = self.ts.generate_table_shared_access_signature( self.table_name, TablePermissions.UPDATE, datetime.utcnow() + timedelta(hours=1), ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) updated_entity = self._create_updated_entity_dict(entity.PartitionKey, entity.RowKey) resp = service.update_entity(self.table_name, updated_entity) # Assert received_entity = self.ts.get_entity(self.table_name, entity.PartitionKey, entity.RowKey) self._assert_updated_entity(received_entity)
def test_sas_signed_identifier(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange entity = self._insert_random_entity() access_policy = AccessPolicy() access_policy.start = '2011-10-11' access_policy.expiry = '2018-10-12' access_policy.permission = TablePermissions.QUERY identifiers = {'testid': access_policy} entities = self.ts.set_table_acl(self.table_name, identifiers) token = self.ts.generate_table_shared_access_signature( self.table_name, id='testid', ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) entities = list(self.ts.query_entities(self.table_name, filter="PartitionKey eq '{}'".format(entity.PartitionKey))) # Assert self.assertEqual(len(entities), 1) self._assert_default_entity(entities[0])
def test_get_blob_to_stream_with_progress_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act progress = [] def callback(current, total): progress.append((current, total)) with open(FILE_PATH, 'wb') as stream: blob = self.bs.get_blob_to_stream( self.container_name, self.byte_blob, stream, progress_callback=callback, max_connections=5) # Assert self.assertIsInstance(blob, Blob) with open(FILE_PATH, 'rb') as stream: actual = stream.read() self.assertEqual(self.byte_data, actual) self.assert_download_progress(len(self.byte_data), self.bs.MAX_CHUNK_GET_SIZE, progress, single_download=False)
def test_sas_update(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange entity = self._insert_random_entity() token = self.ts.generate_table_shared_access_signature( self.table_name, TablePermissions.UPDATE, datetime.utcnow() + timedelta(hours=1), ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) updated_entity = self._create_updated_entity_dict( entity.PartitionKey, entity.RowKey) resp = service.update_entity(self.table_name, updated_entity) # Assert received_entity = self.ts.get_entity(self.table_name, entity.PartitionKey, entity.RowKey) self._assert_updated_entity(received_entity)
def test_get_blob_to_path_with_progress_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act progress = [] def callback(current, total): progress.append((current, total)) blob = self.bs.get_blob_to_path(self.container_name, self.byte_blob, FILE_PATH, progress_callback=callback, max_connections=2) # Assert self.assertIsInstance(blob, Blob) with open(FILE_PATH, 'rb') as stream: actual = stream.read() self.assertEqual(self.byte_data, actual) self.assert_download_progress(len(self.byte_data), self.bs.MAX_CHUNK_GET_SIZE, progress, single_download=False)
def test_sas_access_blob(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._create_block_blob() token = self.bs.generate_blob_shared_access_signature( self.container_name, blob_name, permission=BlobPermissions.READ, expiry=datetime.utcnow() + timedelta(hours=1), ) # Act service = BlockBlobService( self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, request_session=requests.Session(), ) self._set_service_options(service, self.settings) result = service.get_blob_to_bytes(self.container_name, blob_name) # Assert self.assertEqual(self.byte_data, result.content)
def test_sas_signed_identifier(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._create_block_blob() access_policy = AccessPolicy() access_policy.start = '2011-10-11' access_policy.expiry = '2018-10-12' access_policy.permission = BlobPermissions.READ identifiers = {'testid': access_policy} resp = self.bs.set_container_acl(self.container_name, identifiers) token = self.bs.generate_blob_shared_access_signature( self.container_name, blob_name, id='testid' ) # Act service = BlockBlobService( self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, request_session=requests.Session(), ) self._set_service_options(service, self.settings) result = service.get_blob_to_bytes(self.container_name, blob_name) # Assert self.assertEqual(self.byte_data, result.content)
def test_ranged_get_blob_to_path_md5_without_end_range_fail(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act with self.assertRaises(ValueError): blob = self.bs.get_blob_to_path( self.container_name, self.byte_blob, FILE_PATH, start_range=1, range_get_content_md5=True, max_connections=5)
def test_get_blob_to_bytes_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act blob = self.bs.get_blob_to_bytes(self.container_name, self.byte_blob, max_connections=2) # Assert self.assertEqual(self.byte_data, blob.content)
def test_get_blob_to_stream_non_seekable_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act with open(FILE_PATH, 'wb') as stream: non_seekable_stream = StorageGetBlobTest.NonSeekableFile(stream) with self.assertRaises(BaseException): blob = self.bs.get_blob_to_stream( self.container_name, self.byte_blob, non_seekable_stream, max_connections=2)
def test_create_blob_from_bytes_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._get_blob_reference() data = self.get_random_bytes(LARGE_BLOB_SIZE) # Act self.bs.create_blob_from_bytes(self.container_name, blob_name, data, max_connections=5) # Assert self.assertBlobEqual(self.container_name, blob_name, data)
def test_ranged_get_blob_to_path_md5_without_end_range_fail(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act with self.assertRaises(ValueError): blob = self.bs.get_blob_to_path(self.container_name, self.byte_blob, FILE_PATH, start_range=1, range_get_content_md5=True, max_connections=5)
def test_get_blob_to_text_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange text_blob = self.get_resource_name('textblob') text_data = self.get_random_text_data(self.bs.MAX_SINGLE_GET_SIZE + 1) self.bs.create_blob_from_text(self.container_name, text_blob, text_data) # Act blob = self.bs.get_blob_to_text(self.container_name, text_blob, max_connections=5) # Assert self.assertEqual(text_data, blob.content)
def test_get_blob_to_path_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act blob = self.bs.get_blob_to_path( self.container_name, self.byte_blob, FILE_PATH, max_connections=5) # Assert self.assertIsInstance(blob, Blob) with open(FILE_PATH, 'rb') as stream: actual = stream.read() self.assertEqual(self.byte_data, actual)
def test_create_blob_from_bytes_chunked_upload_with_index_and_count_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._get_blob_reference() data = self.get_random_bytes(LARGE_BLOB_SIZE) index = 512 count = len(data) - 1024 # Act self.bs.create_blob_from_bytes(self.container_name, blob_name, data, index, count, max_connections=5) # Assert self.assertBlobEqual(self.container_name, blob_name, data[index : index + count])
def test_get_blob_to_stream_non_seekable_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act with open(FILE_PATH, 'wb') as stream: non_seekable_stream = StorageGetBlobTest.NonSeekableFile(stream) with self.assertRaises(BaseException): blob = self.bs.get_blob_to_stream(self.container_name, self.byte_blob, non_seekable_stream, max_connections=2)
def test_create_blob_from_path_chunked_upload_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._get_blob_reference() data = self.get_random_bytes(LARGE_BLOB_SIZE) with open(FILE_PATH, "wb") as stream: stream.write(data) # Act resp = self.bs.create_blob_from_path(self.container_name, blob_name, FILE_PATH, max_connections=5) # Assert self.assertBlobEqual(self.container_name, blob_name, data)
def test_get_blob_to_stream_non_seekable(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act with open(FILE_PATH, 'wb') as stream: non_seekable_stream = StorageGetBlobTest.NonSeekableFile(stream) blob = self.bs.get_blob_to_stream(self.container_name, self.byte_blob, non_seekable_stream) # Assert self.assertIsInstance(blob, Blob) with open(FILE_PATH, 'rb') as stream: actual = stream.read() self.assertEqual(self.byte_data, actual)
def test_create_blob_from_bytes_chunked_upload_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._get_blob_reference() data = self.get_random_bytes(LARGE_BLOB_SIZE) # Act self.bs.create_blob_from_bytes(self.container_name, blob_name, data, max_connections=5) # Assert self.assertBlobEqual(self.container_name, blob_name, data)
def test_append_blob_from_stream_chunked_upload_with_count_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._create_blob() data = self.get_random_bytes(LARGE_BLOB_SIZE) with open(FILE_PATH, 'wb') as stream: stream.write(data) # Act blob_size = len(data) - 301 with open(FILE_PATH, 'rb') as stream: self.bs.append_blob_from_stream(self.container_name, blob_name, stream, blob_size) # Assert self.assertBlobEqual(self.container_name, blob_name, data[:blob_size])
def test_get_blob_to_bytes_with_progress_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act progress = [] def callback(current, total): progress.append((current, total)) blob = self.bs.get_blob_to_bytes(self.container_name, self.byte_blob, progress_callback=callback, max_connections=2) # Assert self.assertEqual(self.byte_data, blob.content) self.assert_download_progress(len(self.byte_data), self.bs.MAX_CHUNK_GET_SIZE, progress, single_download=False)
def test_create_blob_from_stream_non_seekable_chunked_upload_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange blob_name = self._get_blob_reference() data = self.get_random_bytes(LARGE_BLOB_SIZE) with open(FILE_PATH, 'wb') as stream: stream.write(data) # Act with open(FILE_PATH, 'rb') as stream: non_seekable_file = StorageBlockBlobTest.NonSeekableFile(stream) # Parallel uploads require that the file be seekable with self.assertRaises(AttributeError): self.bs.create_blob_from_stream(self.container_name, blob_name, non_seekable_file, max_connections=5)
def test_get_blob_to_path_parallel(self): # parallel tests introduce random order of requests, can only run live if TestMode.need_recordingfile(self.test_mode): return # Arrange # Act blob = self.bs.get_blob_to_path(self.container_name, self.byte_blob, FILE_PATH, max_connections=5) # Assert self.assertIsInstance(blob, Blob) with open(FILE_PATH, 'rb') as stream: actual = stream.read() self.assertEqual(self.byte_data, actual)
def test_sas_signed_identifier(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange access_policy = AccessPolicy() access_policy.start = '2011-10-11' access_policy.expiry = '2018-10-12' access_policy.permission = QueuePermissions.READ identifiers = {'testid': access_policy} queue_name = self._create_queue() resp = self.qs.set_queue_acl(queue_name, identifiers) self.qs.put_message(queue_name, u'message1') token = self.qs.generate_queue_shared_access_signature(queue_name, id='testid') # Act service = QueueService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) result = service.peek_messages(queue_name) # Assert self.assertIsNotNone(result) self.assertEqual(1, len(result)) message = result[0] self.assertIsNotNone(message) self.assertNotEqual('', message.id) self.assertEqual(u'message1', message.content)
def test_account_sas(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recordingfile(self.test_mode): return # Arrange table_name = self._create_table() entity = { 'PartitionKey': 'test', 'RowKey': 'test1', 'text': 'hello', } self.ts.insert_entity(table_name, entity) entity['RowKey'] = 'test2' self.ts.insert_entity(table_name, entity) token = self.ts.generate_account_shared_access_signature( ResourceTypes.OBJECT, AccountPermissions.READ, datetime.utcnow() + timedelta(hours=1), datetime.utcnow() - timedelta(minutes=1), ) # Act service = TableService( account_name=self.settings.STORAGE_ACCOUNT_NAME, sas_token=token, ) self._set_service_options(service, self.settings) entities = list(service.query_entities(table_name)) # Assert self.assertEqual(len(entities), 2) self.assertEqual(entities[0].text, 'hello') self.assertEqual(entities[1].text, 'hello')