Skip to content

Commit ae0aa99

Browse files
dmitry-fadmitry-fa
authored
test: converting a portion of tests from easymock to mockito (#330)
1 parent 6c18c88 commit ae0aa99

File tree

2 files changed

+228
-142
lines changed

2 files changed

+228
-142
lines changed

‎google-cloud-storage/src/test/java/com/google/cloud/storage/StorageImplMockitoTest.java

+228-11
Original file line numberDiff line numberDiff line change
@@ -16,21 +16,30 @@
1616

1717
package com.google.cloud.storage;
1818

19+
import static org.junit.Assert.assertArrayEquals;
1920
import static org.junit.Assert.assertEquals;
21+
import static org.junit.Assert.assertNotNull;
2022
import static org.junit.Assert.assertSame;
21-
import static org.mockito.Mockito.any;
23+
import static org.junit.Assert.assertTrue;
24+
import static org.junit.Assert.fail;
25+
import static org.mockito.Mockito.doReturn;
26+
import static org.mockito.Mockito.doThrow;
2227
import static org.mockito.Mockito.mock;
23-
import static org.mockito.Mockito.when;
2428

2529
import com.google.api.core.ApiClock;
2630
import com.google.cloud.Identity;
2731
import com.google.cloud.Policy;
32+
import com.google.cloud.ReadChannel;
2833
import com.google.cloud.ServiceOptions;
34+
import com.google.cloud.Tuple;
35+
import com.google.cloud.WriteChannel;
2936
import com.google.cloud.storage.spi.StorageRpcFactory;
3037
import com.google.cloud.storage.spi.v1.StorageRpc;
3138
import com.google.common.collect.ImmutableList;
3239
import com.google.common.collect.ImmutableMap;
3340
import com.google.common.io.BaseEncoding;
41+
import java.io.IOException;
42+
import java.nio.ByteBuffer;
3443
import java.security.Key;
3544
import java.security.KeyFactory;
3645
import java.security.NoSuchAlgorithmException;
@@ -40,11 +49,15 @@
4049
import java.security.spec.InvalidKeySpecException;
4150
import java.security.spec.PKCS8EncodedKeySpec;
4251
import java.security.spec.X509EncodedKeySpec;
52+
import java.util.Arrays;
4353
import java.util.Map;
4454
import javax.crypto.spec.SecretKeySpec;
4555
import org.junit.Before;
4656
import org.junit.BeforeClass;
4757
import org.junit.Test;
58+
import org.mockito.Mockito;
59+
import org.mockito.invocation.InvocationOnMock;
60+
import org.mockito.stubbing.Answer;
4861

4962
public class StorageImplMockitoTest {
5063

@@ -358,11 +371,28 @@ public static void beforeClass() throws NoSuchAlgorithmException, InvalidKeySpec
358371
publicKey = keyFactory.generatePublic(publicKeySpec);
359372
}
360373

374+
private static final RuntimeException STORAGE_FAILURE =
375+
new RuntimeException("Something went wrong");
376+
377+
private static final RuntimeException UNEXPECTED_CALL_EXCEPTION =
378+
new RuntimeException("Unexpected call");
379+
private static final Answer UNEXPECTED_CALL_ANSWER =
380+
new Answer<Object>() {
381+
@Override
382+
public Object answer(InvocationOnMock invocation) {
383+
throw new IllegalArgumentException(
384+
"Unexpected call of "
385+
+ invocation.getMethod()
386+
+ " with "
387+
+ Arrays.toString(invocation.getArguments()));
388+
};
389+
};
390+
361391
@Before
362392
public void setUp() {
363-
rpcFactoryMock = mock(StorageRpcFactory.class);
364-
storageRpcMock = mock(StorageRpc.class);
365-
when(rpcFactoryMock.create(any(StorageOptions.class))).thenReturn(storageRpcMock);
393+
rpcFactoryMock = mock(StorageRpcFactory.class, UNEXPECTED_CALL_ANSWER);
394+
storageRpcMock = mock(StorageRpc.class, UNEXPECTED_CALL_ANSWER);
395+
doReturn(storageRpcMock).when(rpcFactoryMock).create(Mockito.any(StorageOptions.class));
366396
options =
367397
StorageOptions.newBuilder()
368398
.setProjectId("projectId")
@@ -395,22 +425,209 @@ public void testGetOptions() {
395425

396426
@Test
397427
public void testCreateBucket() {
398-
when(storageRpcMock.create(BUCKET_INFO1.toPb(), EMPTY_RPC_OPTIONS))
399-
.thenReturn(BUCKET_INFO1.toPb())
400-
.thenThrow(new RuntimeException("Fail"));
428+
doReturn(BUCKET_INFO1.toPb())
429+
.doThrow(UNEXPECTED_CALL_EXCEPTION)
430+
.when(storageRpcMock)
431+
.create(BUCKET_INFO1.toPb(), EMPTY_RPC_OPTIONS);
401432
initializeService();
402433
Bucket bucket = storage.create(BUCKET_INFO1);
403434
assertEquals(expectedBucket1, bucket);
404435
}
405436

406437
@Test
407438
public void testCreateBucketWithOptions() {
408-
when(storageRpcMock.create(BUCKET_INFO1.toPb(), BUCKET_TARGET_OPTIONS))
409-
.thenReturn(BUCKET_INFO1.toPb())
410-
.thenThrow(new RuntimeException("Fail"));
439+
doReturn(BUCKET_INFO1.toPb())
440+
.doThrow(UNEXPECTED_CALL_EXCEPTION)
441+
.when(storageRpcMock)
442+
.create(BUCKET_INFO1.toPb(), BUCKET_TARGET_OPTIONS);
411443
initializeService();
412444
Bucket bucket =
413445
storage.create(BUCKET_INFO1, BUCKET_TARGET_METAGENERATION, BUCKET_TARGET_PREDEFINED_ACL);
414446
assertEquals(expectedBucket1, bucket);
415447
}
448+
449+
@Test
450+
public void testCreateBucketFailure() {
451+
doThrow(STORAGE_FAILURE).when(storageRpcMock).create(BUCKET_INFO1.toPb(), EMPTY_RPC_OPTIONS);
452+
initializeService();
453+
try {
454+
storage.create(BUCKET_INFO1);
455+
fail();
456+
} catch (StorageException e) {
457+
assertEquals(STORAGE_FAILURE, e.getCause());
458+
}
459+
}
460+
461+
private void verifyChannelRead(ReadChannel channel, byte[] bytes) throws IOException {
462+
assertNotNull(channel);
463+
assertTrue(channel.isOpen());
464+
465+
ByteBuffer buffer = ByteBuffer.allocate(42);
466+
byte[] expectedBytes = new byte[buffer.capacity()];
467+
System.arraycopy(bytes, 0, expectedBytes, 0, bytes.length);
468+
469+
int size = channel.read(buffer);
470+
assertEquals(bytes.length, size);
471+
assertEquals(bytes.length, buffer.position());
472+
assertArrayEquals(expectedBytes, buffer.array());
473+
}
474+
475+
@Test
476+
public void testReader() {
477+
initializeService();
478+
ReadChannel channel = storage.reader(BUCKET_NAME1, BLOB_NAME1);
479+
assertNotNull(channel);
480+
assertTrue(channel.isOpen());
481+
// Storage.reader() does not issue any RPC, channel.read() does
482+
try {
483+
channel.read(ByteBuffer.allocate(100));
484+
fail();
485+
} catch (IOException e) {
486+
assertTrue(e.getMessage().contains("java.lang.IllegalArgumentException: Unexpected call"));
487+
}
488+
}
489+
490+
@Test
491+
public void testReaderWithOptions() throws IOException {
492+
doReturn(Tuple.of("etag", BLOB_CONTENT))
493+
.doThrow(UNEXPECTED_CALL_EXCEPTION)
494+
.when(storageRpcMock)
495+
.read(BLOB_INFO2.toPb(), BLOB_SOURCE_OPTIONS, 0, DEFAULT_CHUNK_SIZE);
496+
initializeService();
497+
ReadChannel channel =
498+
storage.reader(
499+
BUCKET_NAME1, BLOB_NAME2, BLOB_SOURCE_GENERATION, BLOB_SOURCE_METAGENERATION);
500+
verifyChannelRead(channel, BLOB_CONTENT);
501+
}
502+
503+
@Test
504+
public void testReaderWithDecryptionKey() throws IOException {
505+
doReturn(Tuple.of("a", BLOB_CONTENT), Tuple.of("b", BLOB_SUB_CONTENT))
506+
.doThrow(UNEXPECTED_CALL_EXCEPTION)
507+
.when(storageRpcMock)
508+
.read(BLOB_INFO2.toPb(), ENCRYPTION_KEY_OPTIONS, 0, DEFAULT_CHUNK_SIZE);
509+
initializeService();
510+
ReadChannel channel =
511+
storage.reader(BUCKET_NAME1, BLOB_NAME2, Storage.BlobSourceOption.decryptionKey(KEY));
512+
513+
verifyChannelRead(channel, BLOB_CONTENT);
514+
channel =
515+
storage.reader(
516+
BUCKET_NAME1, BLOB_NAME2, Storage.BlobSourceOption.decryptionKey(BASE64_KEY));
517+
verifyChannelRead(channel, BLOB_SUB_CONTENT);
518+
}
519+
520+
@Test
521+
public void testReaderWithOptionsFromBlobId() throws IOException {
522+
doReturn(Tuple.of("etag", BLOB_CONTENT))
523+
.doThrow(UNEXPECTED_CALL_EXCEPTION)
524+
.when(storageRpcMock)
525+
.read(BLOB_INFO1.getBlobId().toPb(), BLOB_SOURCE_OPTIONS, 0, DEFAULT_CHUNK_SIZE);
526+
initializeService();
527+
ReadChannel channel =
528+
storage.reader(
529+
BLOB_INFO1.getBlobId(),
530+
BLOB_SOURCE_GENERATION_FROM_BLOB_ID,
531+
BLOB_SOURCE_METAGENERATION);
532+
verifyChannelRead(channel, BLOB_CONTENT);
533+
}
534+
535+
@Test
536+
public void testReaderFailure() throws IOException {
537+
doThrow(STORAGE_FAILURE)
538+
.when(storageRpcMock)
539+
.read(BLOB_INFO2.getBlobId().toPb(), EMPTY_RPC_OPTIONS, 0, DEFAULT_CHUNK_SIZE);
540+
initializeService();
541+
ReadChannel channel = storage.reader(BUCKET_NAME1, BLOB_NAME2);
542+
assertNotNull(channel);
543+
assertTrue(channel.isOpen());
544+
try {
545+
channel.read(ByteBuffer.allocate(42));
546+
fail();
547+
} catch (IOException e) {
548+
assertTrue(e.getMessage().contains(STORAGE_FAILURE.toString()));
549+
}
550+
}
551+
552+
@Test
553+
public void testWriter() {
554+
BlobInfo.Builder infoBuilder = BLOB_INFO1.toBuilder();
555+
BlobInfo infoWithHashes = infoBuilder.setMd5(CONTENT_MD5).setCrc32c(CONTENT_CRC32C).build();
556+
BlobInfo infoWithoutHashes = infoBuilder.setMd5(null).setCrc32c(null).build();
557+
doReturn("upload-id")
558+
.doThrow(UNEXPECTED_CALL_EXCEPTION)
559+
.when(storageRpcMock)
560+
.open(infoWithoutHashes.toPb(), EMPTY_RPC_OPTIONS);
561+
initializeService();
562+
WriteChannel channel = storage.writer(infoWithHashes);
563+
assertNotNull(channel);
564+
assertTrue(channel.isOpen());
565+
}
566+
567+
@Test
568+
public void testWriterWithOptions() {
569+
BlobInfo info = BLOB_INFO1.toBuilder().setMd5(CONTENT_MD5).setCrc32c(CONTENT_CRC32C).build();
570+
doReturn("upload-id")
571+
.doThrow(UNEXPECTED_CALL_EXCEPTION)
572+
.when(storageRpcMock)
573+
.open(info.toPb(), BLOB_TARGET_OPTIONS_CREATE);
574+
initializeService();
575+
WriteChannel channel =
576+
storage.writer(
577+
info,
578+
BLOB_WRITE_METAGENERATION,
579+
BLOB_WRITE_NOT_EXIST,
580+
BLOB_WRITE_PREDEFINED_ACL,
581+
BLOB_WRITE_CRC2C,
582+
BLOB_WRITE_MD5_HASH);
583+
assertNotNull(channel);
584+
assertTrue(channel.isOpen());
585+
}
586+
587+
@Test
588+
public void testWriterWithEncryptionKey() {
589+
BlobInfo info = BLOB_INFO1.toBuilder().setMd5(null).setCrc32c(null).build();
590+
doReturn("upload-id-1", "upload-id-2")
591+
.doThrow(UNEXPECTED_CALL_EXCEPTION)
592+
.when(storageRpcMock)
593+
.open(info.toPb(), ENCRYPTION_KEY_OPTIONS);
594+
initializeService();
595+
WriteChannel channel = storage.writer(info, Storage.BlobWriteOption.encryptionKey(KEY));
596+
assertNotNull(channel);
597+
assertTrue(channel.isOpen());
598+
channel = storage.writer(info, Storage.BlobWriteOption.encryptionKey(BASE64_KEY));
599+
assertNotNull(channel);
600+
assertTrue(channel.isOpen());
601+
}
602+
603+
@Test
604+
public void testWriterWithKmsKeyName() {
605+
BlobInfo info = BLOB_INFO1.toBuilder().setMd5(null).setCrc32c(null).build();
606+
doReturn("upload-id-1", "upload-id-2")
607+
.doThrow(UNEXPECTED_CALL_EXCEPTION)
608+
.when(storageRpcMock)
609+
.open(info.toPb(), KMS_KEY_NAME_OPTIONS);
610+
initializeService();
611+
WriteChannel channel = storage.writer(info, Storage.BlobWriteOption.kmsKeyName(KMS_KEY_NAME));
612+
assertNotNull(channel);
613+
assertTrue(channel.isOpen());
614+
channel = storage.writer(info, Storage.BlobWriteOption.kmsKeyName(KMS_KEY_NAME));
615+
assertNotNull(channel);
616+
assertTrue(channel.isOpen());
617+
}
618+
619+
@Test
620+
public void testWriterFailure() {
621+
BlobInfo.Builder infoBuilder = BLOB_INFO1.toBuilder();
622+
BlobInfo infoWithHashes = infoBuilder.setMd5(CONTENT_MD5).setCrc32c(CONTENT_CRC32C).build();
623+
BlobInfo infoWithoutHashes = infoBuilder.setMd5(null).setCrc32c(null).build();
624+
doThrow(STORAGE_FAILURE).when(storageRpcMock).open(infoWithoutHashes.toPb(), EMPTY_RPC_OPTIONS);
625+
initializeService();
626+
try {
627+
storage.writer(infoWithHashes);
628+
fail();
629+
} catch (StorageException e) {
630+
assertSame(STORAGE_FAILURE, e.getCause());
631+
}
632+
}
416633
}

0 commit comments

Comments
 (0)