@Test
public void testComposeBlobFail() {
String sourceBlobName1 = "test-compose-blob-fail-source-1";
String sourceBlobName2 = "test-compose-blob-fail-source-2";
BlobInfo sourceBlob1 = BlobInfo.builder(BUCKET, sourceBlobName1).build();
BlobInfo sourceBlob2 = BlobInfo.builder(BUCKET, sourceBlobName2).build();
assertNotNull(storage.create(sourceBlob1));
assertNotNull(storage.create(sourceBlob2));
String targetBlobName = "test-compose-blob-fail-target";
BlobInfo targetBlob = BlobInfo.builder(BUCKET, targetBlobName).build();
Storage.ComposeRequest req =
Storage.ComposeRequest.builder()
.addSource(sourceBlobName1, -1L)
.addSource(sourceBlobName2, -1L)
.target(targetBlob)
.build();
try {
storage.compose(req);
fail("StorageException was expected");
} catch (StorageException ex) {
// expected
}
assertTrue(storage.delete(BUCKET, sourceBlobName1));
assertTrue(storage.delete(BUCKET, sourceBlobName2));
}
@Test
public void testListBlobsSelectedFields() {
String[] blobNames = {
"test-list-blobs-selected-fields-blob1", "test-list-blobs-selected-fields-blob2"
};
ImmutableMap metadata = ImmutableMap.of("k", "v");
BlobInfo blob1 =
BlobInfo.builder(BUCKET, blobNames[0]).contentType(CONTENT_TYPE).metadata(metadata).build();
BlobInfo blob2 =
BlobInfo.builder(BUCKET, blobNames[1]).contentType(CONTENT_TYPE).metadata(metadata).build();
assertNotNull(storage.create(blob1));
assertNotNull(storage.create(blob2));
Page<BlobInfo> page =
storage.list(
BUCKET,
Storage.BlobListOption.prefix("test-list-blobs-selected-fields-blob"),
Storage.BlobListOption.fields(BlobField.METADATA));
int index = 0;
for (BlobInfo remoteBlob : page.values()) {
assertEquals(BUCKET, remoteBlob.bucket());
assertEquals(blobNames[index++], remoteBlob.name());
assertEquals(metadata, remoteBlob.metadata());
assertNull(remoteBlob.contentType());
}
assertTrue(storage.delete(BUCKET, blobNames[0]));
assertTrue(storage.delete(BUCKET, blobNames[1]));
}
@Test
public void testCreateBlobFail() {
String blobName = "test-create-blob-fail";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
assertNotNull(storage.create(blob));
try {
storage.create(
blob.toBuilder().generation(-1L).build(),
BLOB_BYTE_CONTENT,
Storage.BlobTargetOption.generationMatch());
fail("StorageException was expected");
} catch (StorageException ex) {
// expected
}
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testGetBlobEmptySelectedFields() {
String blobName = "test-get-empty-selected-fields-blob";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).contentType(CONTENT_TYPE).build();
assertNotNull(storage.create(blob));
BlobInfo remoteBlob = storage.get(blob.blobId(), Storage.BlobGetOption.fields());
assertEquals(blob.blobId(), remoteBlob.blobId());
assertNull(remoteBlob.contentType());
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testDeleteBlobsFail() {
String sourceBlobName1 = "test-delete-blobs-fail-1";
String sourceBlobName2 = "test-delete-blobs-fail-2";
BlobInfo sourceBlob1 = BlobInfo.builder(BUCKET, sourceBlobName1).build();
BlobInfo sourceBlob2 = BlobInfo.builder(BUCKET, sourceBlobName2).build();
assertNotNull(storage.create(sourceBlob1));
List<Boolean> deleteStatus = storage.delete(sourceBlob1.blobId(), sourceBlob2.blobId());
assertTrue(deleteStatus.get(0));
assertTrue(!deleteStatus.get(1));
}
@Test
public void testUpdateBlob() {
String blobName = "test-update-blob";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
assertNotNull(storage.create(blob));
BlobInfo updatedBlob = storage.update(blob.toBuilder().contentType(CONTENT_TYPE).build());
assertNotNull(updatedBlob);
assertEquals(blob.blobId(), updatedBlob.blobId());
assertEquals(CONTENT_TYPE, updatedBlob.contentType());
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testCreateEmptyBlob() {
String blobName = "test-create-empty-blob";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
BlobInfo remoteBlob = storage.create(blob);
assertNotNull(remoteBlob);
assertEquals(blob.blobId(), remoteBlob.blobId());
byte[] readBytes = storage.readAllBytes(BUCKET, blobName);
assertArrayEquals(new byte[0], readBytes);
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testGetBlobsFail() {
String sourceBlobName1 = "test-get-blobs-fail-1";
String sourceBlobName2 = "test-get-blobs-fail-2";
BlobInfo sourceBlob1 = BlobInfo.builder(BUCKET, sourceBlobName1).build();
BlobInfo sourceBlob2 = BlobInfo.builder(BUCKET, sourceBlobName2).build();
assertNotNull(storage.create(sourceBlob1));
List<BlobInfo> remoteBlobs = storage.get(sourceBlob1.blobId(), sourceBlob2.blobId());
assertEquals(sourceBlob1.blobId(), remoteBlobs.get(0).blobId());
assertNull(remoteBlobs.get(1));
assertTrue(storage.delete(BUCKET, sourceBlobName1));
}
@Test
public void testWriteChannelExistingBlob() throws IOException {
String blobName = "test-write-channel-existing-blob";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
BlobInfo remoteBlob = storage.create(blob);
byte[] stringBytes;
try (BlobWriteChannel writer = storage.writer(remoteBlob)) {
stringBytes = BLOB_STRING_CONTENT.getBytes(UTF_8);
writer.write(ByteBuffer.wrap(stringBytes));
}
assertArrayEquals(stringBytes, storage.readAllBytes(blob.blobId()));
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testDeleteBlobFail() {
String blobName = "test-delete-blob-fail";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
assertNotNull(storage.create(blob));
try {
storage.delete(BUCKET, blob.name(), Storage.BlobSourceOption.generationMatch(-1L));
fail("StorageException was expected");
} catch (StorageException ex) {
// expected
}
assertTrue(storage.delete(BUCKET, blob.name()));
}
@Test
public void testCreateBlobStream() throws UnsupportedEncodingException {
String blobName = "test-create-blob-stream";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).contentType(CONTENT_TYPE).build();
ByteArrayInputStream stream = new ByteArrayInputStream(BLOB_STRING_CONTENT.getBytes(UTF_8));
BlobInfo remoteBlob = storage.create(blob, stream);
assertNotNull(remoteBlob);
assertEquals(blob.blobId(), remoteBlob.blobId());
assertEquals(blob.contentType(), remoteBlob.contentType());
byte[] readBytes = storage.readAllBytes(BUCKET, blobName);
assertEquals(BLOB_STRING_CONTENT, new String(readBytes, UTF_8));
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testGetSignedUrl() throws IOException {
String blobName = "test-get-signed-url-blob";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
assertNotNull(storage.create(blob, BLOB_BYTE_CONTENT));
URL url = storage.signUrl(blob, 1, TimeUnit.HOURS);
URLConnection connection = url.openConnection();
byte[] readBytes = new byte[BLOB_BYTE_CONTENT.length];
try (InputStream responseStream = connection.getInputStream()) {
assertEquals(BLOB_BYTE_CONTENT.length, responseStream.read(readBytes));
assertArrayEquals(BLOB_BYTE_CONTENT, readBytes);
assertTrue(storage.delete(BUCKET, blobName));
}
}
@Test
public void testReadChannelFail() throws IOException {
String blobName = "test-read-channel-blob-fail";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
assertNotNull(storage.create(blob));
try (BlobReadChannel reader =
storage.reader(blob.blobId(), Storage.BlobSourceOption.metagenerationMatch(-1L))) {
reader.read(ByteBuffer.allocate(42));
fail("StorageException was expected");
} catch (StorageException ex) {
// expected
}
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testBatchRequest() {
String sourceBlobName1 = "test-batch-request-blob-1";
String sourceBlobName2 = "test-batch-request-blob-2";
BlobInfo sourceBlob1 = BlobInfo.builder(BUCKET, sourceBlobName1).build();
BlobInfo sourceBlob2 = BlobInfo.builder(BUCKET, sourceBlobName2).build();
assertNotNull(storage.create(sourceBlob1));
assertNotNull(storage.create(sourceBlob2));
// Batch update request
BlobInfo updatedBlob1 = sourceBlob1.toBuilder().contentType(CONTENT_TYPE).build();
BlobInfo updatedBlob2 = sourceBlob2.toBuilder().contentType(CONTENT_TYPE).build();
BatchRequest updateRequest =
BatchRequest.builder().update(updatedBlob1).update(updatedBlob2).build();
BatchResponse updateResponse = storage.apply(updateRequest);
assertEquals(2, updateResponse.updates().size());
assertEquals(0, updateResponse.deletes().size());
assertEquals(0, updateResponse.gets().size());
BlobInfo remoteUpdatedBlob1 = updateResponse.updates().get(0).get();
BlobInfo remoteUpdatedBlob2 = updateResponse.updates().get(1).get();
assertEquals(sourceBlob1.blobId(), remoteUpdatedBlob1.blobId());
assertEquals(sourceBlob2.blobId(), remoteUpdatedBlob2.blobId());
assertEquals(updatedBlob1.contentType(), remoteUpdatedBlob1.contentType());
assertEquals(updatedBlob2.contentType(), remoteUpdatedBlob2.contentType());
// Batch get request
BatchRequest getRequest =
BatchRequest.builder().get(BUCKET, sourceBlobName1).get(BUCKET, sourceBlobName2).build();
BatchResponse getResponse = storage.apply(getRequest);
assertEquals(2, getResponse.gets().size());
assertEquals(0, getResponse.deletes().size());
assertEquals(0, getResponse.updates().size());
BlobInfo remoteBlob1 = getResponse.gets().get(0).get();
BlobInfo remoteBlob2 = getResponse.gets().get(1).get();
assertEquals(remoteUpdatedBlob1, remoteBlob1);
assertEquals(remoteUpdatedBlob2, remoteBlob2);
// Batch delete request
BatchRequest deleteRequest =
BatchRequest.builder()
.delete(BUCKET, sourceBlobName1)
.delete(BUCKET, sourceBlobName2)
.build();
BatchResponse deleteResponse = storage.apply(deleteRequest);
assertEquals(2, deleteResponse.deletes().size());
assertEquals(0, deleteResponse.gets().size());
assertEquals(0, deleteResponse.updates().size());
assertTrue(deleteResponse.deletes().get(0).get());
assertTrue(deleteResponse.deletes().get(1).get());
}
@Test
public void testPostSignedUrl() throws IOException {
String blobName = "test-post-signed-url-blob";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
assertNotNull(storage.create(blob));
URL url =
storage.signUrl(blob, 1, TimeUnit.HOURS, Storage.SignUrlOption.httpMethod(HttpMethod.POST));
URLConnection connection = url.openConnection();
connection.setDoOutput(true);
connection.connect();
BlobInfo remoteBlob = storage.get(BUCKET, blobName);
assertNotNull(remoteBlob);
assertEquals(blob.blobId(), remoteBlob.blobId());
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testUpdateBlobMergeMetadata() {
String blobName = "test-update-blob-merge-metadata";
ImmutableMap<String, String> metadata = ImmutableMap.of("k1", "a");
ImmutableMap<String, String> newMetadata = ImmutableMap.of("k2", "b");
ImmutableMap<String, String> expectedMetadata = ImmutableMap.of("k1", "a", "k2", "b");
BlobInfo blob =
BlobInfo.builder(BUCKET, blobName).contentType(CONTENT_TYPE).metadata(metadata).build();
assertNotNull(storage.create(blob));
BlobInfo updatedBlob = storage.update(blob.toBuilder().metadata(newMetadata).build());
assertNotNull(updatedBlob);
assertEquals(blob.blobId(), updatedBlob.blobId());
assertEquals(expectedMetadata, updatedBlob.metadata());
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testCreateBlobMd5Fail() throws UnsupportedEncodingException {
String blobName = "test-create-blob-md5-fail";
BlobInfo blob =
BlobInfo.builder(BUCKET, blobName)
.contentType(CONTENT_TYPE)
.md5("O1R4G1HJSDUISJjoIYmVhQ==")
.build();
ByteArrayInputStream stream = new ByteArrayInputStream(BLOB_STRING_CONTENT.getBytes(UTF_8));
try {
storage.create(blob, stream, Storage.BlobWriteOption.md5Match());
fail("StorageException was expected");
} catch (StorageException ex) {
// expected
}
}
@Test
public void testGetBlobSelectedFields() {
String blobName = "test-get-selected-fields-blob";
BlobInfo blob =
BlobInfo.builder(BUCKET, blobName)
.contentType(CONTENT_TYPE)
.metadata(ImmutableMap.of("k", "v"))
.build();
assertNotNull(storage.create(blob));
BlobInfo remoteBlob =
storage.get(blob.blobId(), Storage.BlobGetOption.fields(BlobField.METADATA));
assertEquals(blob.blobId(), remoteBlob.blobId());
assertEquals(ImmutableMap.of("k", "v"), remoteBlob.metadata());
assertNull(remoteBlob.contentType());
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testUpdateBlobsFail() {
String sourceBlobName1 = "test-update-blobs-fail-1";
String sourceBlobName2 = "test-update-blobs-fail-2";
BlobInfo sourceBlob1 = BlobInfo.builder(BUCKET, sourceBlobName1).build();
BlobInfo sourceBlob2 = BlobInfo.builder(BUCKET, sourceBlobName2).build();
BlobInfo remoteBlob1 = storage.create(sourceBlob1);
assertNotNull(remoteBlob1);
List<BlobInfo> updatedBlobs =
storage.update(
remoteBlob1.toBuilder().contentType(CONTENT_TYPE).build(),
sourceBlob2.toBuilder().contentType(CONTENT_TYPE).build());
assertEquals(sourceBlob1.blobId(), updatedBlobs.get(0).blobId());
assertEquals(CONTENT_TYPE, updatedBlobs.get(0).contentType());
assertNull(updatedBlobs.get(1));
assertTrue(storage.delete(BUCKET, sourceBlobName1));
}
@Test
public void testCopyBlob() {
String sourceBlobName = "test-copy-blob-source";
BlobId source = BlobId.of(BUCKET, sourceBlobName);
ImmutableMap<String, String> metadata = ImmutableMap.of("k", "v");
BlobInfo blob = BlobInfo.builder(source).contentType(CONTENT_TYPE).metadata(metadata).build();
assertNotNull(storage.create(blob, BLOB_BYTE_CONTENT));
String targetBlobName = "test-copy-blob-target";
Storage.CopyRequest req = Storage.CopyRequest.of(source, BlobId.of(BUCKET, targetBlobName));
CopyWriter copyWriter = storage.copy(req);
assertEquals(BUCKET, copyWriter.result().bucket());
assertEquals(targetBlobName, copyWriter.result().name());
assertEquals(CONTENT_TYPE, copyWriter.result().contentType());
assertEquals(metadata, copyWriter.result().metadata());
assertTrue(copyWriter.isDone());
assertTrue(storage.delete(BUCKET, sourceBlobName));
assertTrue(storage.delete(BUCKET, targetBlobName));
}
@Test
public void testBatchRequestFail() {
String blobName = "test-batch-request-blob-fail";
BlobInfo blob = BlobInfo.builder(BUCKET, blobName).build();
assertNotNull(storage.create(blob));
BlobInfo updatedBlob = blob.toBuilder().generation(-1L).build();
BatchRequest batchRequest =
BatchRequest.builder()
.update(updatedBlob, Storage.BlobTargetOption.generationMatch())
.delete(BUCKET, blobName, Storage.BlobSourceOption.generationMatch(-1L))
.get(BUCKET, blobName, Storage.BlobGetOption.generationMatch(-1L))
.build();
BatchResponse updateResponse = storage.apply(batchRequest);
assertEquals(1, updateResponse.updates().size());
assertEquals(1, updateResponse.deletes().size());
assertEquals(1, updateResponse.gets().size());
assertTrue(updateResponse.updates().get(0).failed());
assertTrue(updateResponse.gets().get(0).failed());
assertTrue(updateResponse.deletes().get(0).failed());
assertTrue(storage.delete(BUCKET, blobName));
}
@Test
public void testCopyBlobFail() {
String sourceBlobName = "test-copy-blob-source-fail";
BlobId source = BlobId.of(BUCKET, sourceBlobName);
assertNotNull(storage.create(BlobInfo.builder(source).build(), BLOB_BYTE_CONTENT));
String targetBlobName = "test-copy-blob-target-fail";
BlobInfo target = BlobInfo.builder(BUCKET, targetBlobName).contentType(CONTENT_TYPE).build();
Storage.CopyRequest req =
Storage.CopyRequest.builder()
.source(source)
.sourceOptions(Storage.BlobSourceOption.generationMatch(-1L))
.target(target)
.build();
try {
storage.copy(req);
fail("StorageException was expected");
} catch (StorageException ex) {
// expected
}
assertTrue(storage.delete(BUCKET, sourceBlobName));
}
@Test
public void testComposeBlob() {
String sourceBlobName1 = "test-compose-blob-source-1";
String sourceBlobName2 = "test-compose-blob-source-2";
BlobInfo sourceBlob1 = BlobInfo.builder(BUCKET, sourceBlobName1).build();
BlobInfo sourceBlob2 = BlobInfo.builder(BUCKET, sourceBlobName2).build();
assertNotNull(storage.create(sourceBlob1, BLOB_BYTE_CONTENT));
assertNotNull(storage.create(sourceBlob2, BLOB_BYTE_CONTENT));
String targetBlobName = "test-compose-blob-target";
BlobInfo targetBlob = BlobInfo.builder(BUCKET, targetBlobName).build();
Storage.ComposeRequest req =
Storage.ComposeRequest.of(ImmutableList.of(sourceBlobName1, sourceBlobName2), targetBlob);
BlobInfo remoteBlob = storage.compose(req);
assertNotNull(remoteBlob);
assertEquals(targetBlob.blobId(), remoteBlob.blobId());
byte[] readBytes = storage.readAllBytes(BUCKET, targetBlobName);
byte[] composedBytes = Arrays.copyOf(BLOB_BYTE_CONTENT, BLOB_BYTE_CONTENT.length * 2);
System.arraycopy(
BLOB_BYTE_CONTENT, 0, composedBytes, BLOB_BYTE_CONTENT.length, BLOB_BYTE_CONTENT.length);
assertArrayEquals(composedBytes, readBytes);
assertTrue(storage.delete(BUCKET, sourceBlobName1));
assertTrue(storage.delete(BUCKET, sourceBlobName2));
assertTrue(storage.delete(BUCKET, targetBlobName));
}
@BeforeClass
public static void beforeClass() {
RemoteGcsHelper gcsHelper = RemoteGcsHelper.create();
storage = gcsHelper.options().service();
storage.create(BucketInfo.of(BUCKET));
}