diff --git a/gcloud-java-bigquery/src/main/java/com/google/cloud/bigquery/BigQueryException.java b/gcloud-java-bigquery/src/main/java/com/google/cloud/bigquery/BigQueryException.java index 7f314a01b088..0b0c7d3152e3 100644 --- a/gcloud-java-bigquery/src/main/java/com/google/cloud/bigquery/BigQueryException.java +++ b/gcloud-java-bigquery/src/main/java/com/google/cloud/bigquery/BigQueryException.java @@ -31,7 +31,7 @@ * @see Google Cloud * BigQuery error codes */ -public class BigQueryException extends BaseServiceException { +public final class BigQueryException extends BaseServiceException { // see: https://cloud.google.com/bigquery/troubleshooting-errors private static final Set RETRYABLE_ERRORS = ImmutableSet.of( @@ -44,7 +44,12 @@ public class BigQueryException extends BaseServiceException { private final BigQueryError error; public BigQueryException(int code, String message) { - this(code, message, null); + this(code, message, (Throwable) null); + } + + public BigQueryException(int code, String message, Throwable cause) { + super(code, message, null, true, cause); + this.error = null; } public BigQueryException(int code, String message, BigQueryError error) { @@ -100,6 +105,6 @@ public int hashCode() { */ static BaseServiceException translateAndThrow(RetryHelperException ex) { BaseServiceException.translateAndPropagateIfPossible(ex); - throw new BigQueryException(UNKNOWN_CODE, ex.getMessage()); + throw new BigQueryException(UNKNOWN_CODE, ex.getMessage(), ex.getCause()); } } diff --git a/gcloud-java-bigquery/src/test/java/com/google/cloud/bigquery/BigQueryExceptionTest.java b/gcloud-java-bigquery/src/test/java/com/google/cloud/bigquery/BigQueryExceptionTest.java index b0a32cd7f0c7..e97606bfc463 100644 --- a/gcloud-java-bigquery/src/test/java/com/google/cloud/bigquery/BigQueryExceptionTest.java +++ b/gcloud-java-bigquery/src/test/java/com/google/cloud/bigquery/BigQueryExceptionTest.java @@ -23,6 +23,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import com.google.cloud.BaseServiceException; @@ -86,18 +87,29 @@ public void testBigqueryException() { assertTrue(exception.retryable()); assertTrue(exception.idempotent()); - IOException cause = new SocketTimeoutException(); + IOException cause = new SocketTimeoutException("socketTimeoutMessage"); exception = new BigQueryException(cause); + assertEquals(BigQueryException.UNKNOWN_CODE, exception.code()); assertNull(exception.reason()); - assertNull(exception.getMessage()); + assertEquals("socketTimeoutMessage", exception.getMessage()); + assertEquals(cause, exception.getCause()); assertTrue(exception.retryable()); assertTrue(exception.idempotent()); - assertEquals(cause, exception.getCause()); + assertSame(cause, exception.getCause()); + + exception = new BigQueryException(504, "message", cause); + assertEquals(504, exception.code()); + assertEquals("message", exception.getMessage()); + assertNull(exception.reason()); + assertNull(exception.error()); + assertTrue(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); } @Test public void testTranslateAndThrow() throws Exception { - BigQueryException cause = new BigQueryException(503, "message"); + Exception cause = new BigQueryException(503, "message"); RetryHelperException exceptionMock = createMock(RetryHelperException.class); expect(exceptionMock.getCause()).andReturn(cause).times(2); replay(exceptionMock); @@ -111,5 +123,21 @@ public void testTranslateAndThrow() throws Exception { } finally { verify(exceptionMock); } + cause = new IllegalArgumentException("message"); + exceptionMock = createMock(RetryHelperException.class); + expect(exceptionMock.getMessage()).andReturn("message").times(1); + expect(exceptionMock.getCause()).andReturn(cause).times(2); + replay(exceptionMock); + try { + BigQueryException.translateAndThrow(exceptionMock); + } catch (BaseServiceException ex) { + assertEquals(BigQueryException.UNKNOWN_CODE, ex.code()); + assertEquals("message", ex.getMessage()); + assertFalse(ex.retryable()); + assertTrue(ex.idempotent()); + assertSame(cause, ex.getCause()); + } finally { + verify(exceptionMock); + } } } diff --git a/gcloud-java-datastore/src/main/java/com/google/cloud/datastore/DatastoreException.java b/gcloud-java-datastore/src/main/java/com/google/cloud/datastore/DatastoreException.java index 419cffc7bf3e..42c0079e0a77 100644 --- a/gcloud-java-datastore/src/main/java/com/google/cloud/datastore/DatastoreException.java +++ b/gcloud-java-datastore/src/main/java/com/google/cloud/datastore/DatastoreException.java @@ -30,19 +30,19 @@ * @see Google Cloud * Datastore error codes */ -public class DatastoreException extends BaseServiceException { +public final class DatastoreException extends BaseServiceException { // see https://cloud.google.com/datastore/docs/concepts/errors#Error_Codes" private static final Set RETRYABLE_ERRORS = ImmutableSet.of( new Error(10, "ABORTED"), new Error(4, "DEADLINE_EXCEEDED"), new Error(14, "UNAVAILABLE")); private static final long serialVersionUID = 2663750991205874435L; - public DatastoreException(int code, String message, String reason, Throwable cause) { - super(code, message, reason, true, cause); + public DatastoreException(int code, String message, String reason) { + this(code, message, reason, null); } - public DatastoreException(int code, String message, String reason) { - super(code, message, reason, true); + public DatastoreException(int code, String message, String reason, Throwable cause) { + super(code, message, reason, true, cause); } public DatastoreException(IOException exception) { @@ -63,7 +63,7 @@ protected Set retryableErrors() { */ static DatastoreException translateAndThrow(RetryHelperException ex) { BaseServiceException.translateAndPropagateIfPossible(ex); - throw new DatastoreException(UNKNOWN_CODE, ex.getMessage(), null); + throw new DatastoreException(UNKNOWN_CODE, ex.getMessage(), null, ex.getCause()); } /** diff --git a/gcloud-java-datastore/src/test/java/com/google/cloud/datastore/DatastoreExceptionTest.java b/gcloud-java-datastore/src/test/java/com/google/cloud/datastore/DatastoreExceptionTest.java index cf086ff25ba0..0da45f083210 100644 --- a/gcloud-java-datastore/src/test/java/com/google/cloud/datastore/DatastoreExceptionTest.java +++ b/gcloud-java-datastore/src/test/java/com/google/cloud/datastore/DatastoreExceptionTest.java @@ -23,6 +23,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -66,18 +67,28 @@ public void testDatastoreException() throws Exception { assertFalse(exception.retryable()); assertTrue(exception.idempotent()); - IOException cause = new SocketTimeoutException(); + IOException cause = new SocketTimeoutException("socketTimeoutMessage"); exception = new DatastoreException(cause); + assertEquals(DatastoreException.UNKNOWN_CODE, exception.code()); assertNull(exception.reason()); - assertNull(exception.getMessage()); + assertEquals("socketTimeoutMessage", exception.getMessage()); + assertEquals(cause, exception.getCause()); assertTrue(exception.retryable()); assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); + exception = new DatastoreException(2, "message", "INTERNAL", cause); + assertEquals(2, exception.code()); + assertEquals("INTERNAL", exception.reason()); + assertEquals("message", exception.getMessage()); + assertFalse(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); } @Test public void testTranslateAndThrow() throws Exception { - DatastoreException cause = new DatastoreException(14, "message", "UNAVAILABLE"); + Exception cause = new DatastoreException(14, "message", "UNAVAILABLE"); RetryHelper.RetryHelperException exceptionMock = createMock(RetryHelper.RetryHelperException.class); expect(exceptionMock.getCause()).andReturn(cause).times(2); @@ -92,6 +103,22 @@ public void testTranslateAndThrow() throws Exception { } finally { verify(exceptionMock); } + cause = new IllegalArgumentException("message"); + exceptionMock = createMock(RetryHelper.RetryHelperException.class); + expect(exceptionMock.getMessage()).andReturn("message").times(1); + expect(exceptionMock.getCause()).andReturn(cause).times(2); + replay(exceptionMock); + try { + DatastoreException.translateAndThrow(exceptionMock); + } catch (BaseServiceException ex) { + assertEquals(DatastoreException.UNKNOWN_CODE, ex.code()); + assertEquals("message", ex.getMessage()); + assertFalse(ex.retryable()); + assertTrue(ex.idempotent()); + assertSame(cause, ex.getCause()); + } finally { + verify(exceptionMock); + } } @Test diff --git a/gcloud-java-dns/src/main/java/com/google/cloud/dns/DnsException.java b/gcloud-java-dns/src/main/java/com/google/cloud/dns/DnsException.java index 274ff91b3bd0..90c32aee1681 100644 --- a/gcloud-java-dns/src/main/java/com/google/cloud/dns/DnsException.java +++ b/gcloud-java-dns/src/main/java/com/google/cloud/dns/DnsException.java @@ -28,7 +28,7 @@ /** * DNS service exception. */ -public class DnsException extends BaseServiceException { +public final class DnsException extends BaseServiceException { // see: https://cloud.google.com/dns/troubleshooting private static final Set RETRYABLE_ERRORS = ImmutableSet.of( @@ -48,8 +48,8 @@ public DnsException(GoogleJsonError error, boolean idempotent) { super(error, idempotent); } - private DnsException(int code, String message) { - super(code, message, null, true); + public DnsException(int code, String message, Throwable cause) { + super(code, message, null, true, cause); } @Override @@ -66,6 +66,6 @@ protected Set retryableErrors() { */ static DnsException translateAndThrow(RetryHelperException ex) { BaseServiceException.translateAndPropagateIfPossible(ex); - throw new DnsException(UNKNOWN_CODE, ex.getMessage()); + throw new DnsException(UNKNOWN_CODE, ex.getMessage(), ex.getCause()); } } diff --git a/gcloud-java-dns/src/test/java/com/google/cloud/dns/DnsExceptionTest.java b/gcloud-java-dns/src/test/java/com/google/cloud/dns/DnsExceptionTest.java new file mode 100644 index 000000000000..f97d9f697baa --- /dev/null +++ b/gcloud-java-dns/src/test/java/com/google/cloud/dns/DnsExceptionTest.java @@ -0,0 +1,138 @@ +/* + * Copyright 2016 Google Inc. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.cloud.dns; + +import static org.easymock.EasyMock.createMock; +import static org.easymock.EasyMock.expect; +import static org.easymock.EasyMock.replay; +import static org.easymock.EasyMock.verify; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; + +import com.google.api.client.googleapis.json.GoogleJsonError; +import com.google.cloud.BaseServiceException; +import com.google.cloud.RetryHelper.RetryHelperException; + +import org.junit.Test; + +import java.io.IOException; +import java.net.SocketTimeoutException; + +public class DnsExceptionTest { + + @Test + public void testDnsException() throws Exception { + IOException cause = new SocketTimeoutException("socketTimeoutMessage"); + DnsException exception = new DnsException(500, "message", cause); + assertEquals(500, exception.code()); + assertEquals("message", exception.getMessage()); + assertNull(exception.reason()); + assertTrue(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); + + exception = new DnsException(502, "message", cause); + assertEquals(502, exception.code()); + assertEquals("message", exception.getMessage()); + assertNull(exception.reason()); + assertTrue(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); + + exception = new DnsException(503, "message", cause); + assertEquals(503, exception.code()); + assertEquals("message", exception.getMessage()); + assertNull(exception.reason()); + assertTrue(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); + + exception = new DnsException(429, "message", cause); + assertEquals(429, exception.code()); + assertEquals("message", exception.getMessage()); + assertNull(exception.reason()); + assertTrue(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); + + exception = new DnsException(404, "message", cause); + assertEquals(404, exception.code()); + assertEquals("message", exception.getMessage()); + assertNull(exception.reason()); + assertFalse(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); + + exception = new DnsException(cause, true); + assertEquals(DnsException.UNKNOWN_CODE, exception.code()); + assertNull(exception.reason()); + assertEquals("socketTimeoutMessage", exception.getMessage()); + assertEquals(cause, exception.getCause()); + assertTrue(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); + + GoogleJsonError error = new GoogleJsonError(); + error.setCode(503); + error.setMessage("message"); + exception = new DnsException(error, true); + assertEquals(503, exception.code()); + assertEquals("message", exception.getMessage()); + assertTrue(exception.retryable()); + assertTrue(exception.idempotent()); + } + + @Test + public void testTranslateAndThrow() throws Exception { + IOException timeoutException = new SocketTimeoutException("message"); + Exception cause = new DnsException(timeoutException, true); + RetryHelperException exceptionMock = createMock(RetryHelperException.class); + expect(exceptionMock.getCause()).andReturn(cause).times(2); + replay(exceptionMock); + try { + DnsException.translateAndThrow(exceptionMock); + } catch (BaseServiceException ex) { + assertEquals(DnsException.UNKNOWN_CODE, ex.code()); + assertNull(ex.reason()); + assertEquals("message", ex.getMessage()); + assertEquals(timeoutException, ex.getCause()); + assertTrue(ex.retryable()); + assertTrue(ex.idempotent()); + } finally { + verify(exceptionMock); + } + cause = new IllegalArgumentException("message"); + exceptionMock = createMock(RetryHelperException.class); + expect(exceptionMock.getMessage()).andReturn("message").times(1); + expect(exceptionMock.getCause()).andReturn(cause).times(2); + replay(exceptionMock); + try { + DnsException.translateAndThrow(exceptionMock); + } catch (BaseServiceException ex) { + assertEquals(DnsException.UNKNOWN_CODE, ex.code()); + assertEquals("message", ex.getMessage()); + assertFalse(ex.retryable()); + assertTrue(ex.idempotent()); + assertSame(cause, ex.getCause()); + } finally { + verify(exceptionMock); + } + } +} diff --git a/gcloud-java-dns/src/test/java/com/google/cloud/dns/ZoneTest.java b/gcloud-java-dns/src/test/java/com/google/cloud/dns/ZoneTest.java index e1f6c8917647..aefc716bf46a 100644 --- a/gcloud-java-dns/src/test/java/com/google/cloud/dns/ZoneTest.java +++ b/gcloud-java-dns/src/test/java/com/google/cloud/dns/ZoneTest.java @@ -64,7 +64,7 @@ public class ZoneTest { ChangeRequestInfo.builder().generatedId("someid").build(); private static final ChangeRequestInfo CHANGE_REQUEST_NO_ID = ChangeRequestInfo.builder().build(); - private static final DnsException EXCEPTION = createStrictMock(DnsException.class); + private static final DnsException EXCEPTION = new DnsException(-1, "message", null); private static final DnsOptions OPTIONS = createStrictMock(DnsOptions.class); private Dns dns; diff --git a/gcloud-java-resourcemanager/src/main/java/com/google/cloud/resourcemanager/ResourceManagerException.java b/gcloud-java-resourcemanager/src/main/java/com/google/cloud/resourcemanager/ResourceManagerException.java index 1df014e450ee..2a6906fc0090 100644 --- a/gcloud-java-resourcemanager/src/main/java/com/google/cloud/resourcemanager/ResourceManagerException.java +++ b/gcloud-java-resourcemanager/src/main/java/com/google/cloud/resourcemanager/ResourceManagerException.java @@ -30,7 +30,7 @@ * @see Google Cloud * Resource Manager error codes */ -public class ResourceManagerException extends BaseServiceException { +public final class ResourceManagerException extends BaseServiceException { // see https://cloud.google.com/resource-manager/v1/errors/core_errors private static final Set RETRYABLE_ERRORS = ImmutableSet.of( @@ -48,7 +48,11 @@ public class ResourceManagerException extends BaseServiceException { private static final long serialVersionUID = -9207194488966554136L; public ResourceManagerException(int code, String message) { - super(code, message, null, true); + this(code, message, null); + } + + public ResourceManagerException(int code, String message, Throwable cause) { + super(code, message, null, true, cause); } public ResourceManagerException(IOException exception) { @@ -70,6 +74,6 @@ protected Set retryableErrors() { */ static ResourceManagerException translateAndThrow(RetryHelperException ex) { BaseServiceException.translateAndPropagateIfPossible(ex); - throw new ResourceManagerException(UNKNOWN_CODE, ex.getMessage()); + throw new ResourceManagerException(UNKNOWN_CODE, ex.getMessage(), ex.getCause()); } } diff --git a/gcloud-java-resourcemanager/src/test/java/com/google/cloud/resourcemanager/ResourceManagerExceptionTest.java b/gcloud-java-resourcemanager/src/test/java/com/google/cloud/resourcemanager/ResourceManagerExceptionTest.java index 2ac8d1acba7f..8e725b366a6b 100644 --- a/gcloud-java-resourcemanager/src/test/java/com/google/cloud/resourcemanager/ResourceManagerExceptionTest.java +++ b/gcloud-java-resourcemanager/src/test/java/com/google/cloud/resourcemanager/ResourceManagerExceptionTest.java @@ -23,6 +23,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import com.google.cloud.BaseServiceException; @@ -71,12 +72,20 @@ public void testResourceManagerException() { assertNull(exception.getMessage()); assertTrue(exception.retryable()); assertTrue(exception.idempotent()); - assertEquals(cause, exception.getCause()); + assertSame(cause, exception.getCause()); + + exception = new ResourceManagerException(404, "message", cause); + assertEquals(404, exception.code()); + assertEquals("message", exception.getMessage()); + assertNull(exception.reason()); + assertFalse(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); } @Test public void testTranslateAndThrow() throws Exception { - ResourceManagerException cause = new ResourceManagerException(503, "message"); + Exception cause = new ResourceManagerException(503, "message"); RetryHelperException exceptionMock = createMock(RetryHelperException.class); expect(exceptionMock.getCause()).andReturn(cause).times(2); replay(exceptionMock); @@ -90,5 +99,21 @@ public void testTranslateAndThrow() throws Exception { } finally { verify(exceptionMock); } + cause = new IllegalArgumentException("message"); + exceptionMock = createMock(RetryHelperException.class); + expect(exceptionMock.getMessage()).andReturn("message").times(1); + expect(exceptionMock.getCause()).andReturn(cause).times(2); + replay(exceptionMock); + try { + ResourceManagerException.translateAndThrow(exceptionMock); + } catch (BaseServiceException ex) { + assertEquals(ResourceManagerException.UNKNOWN_CODE, ex.code()); + assertEquals("message", ex.getMessage()); + assertFalse(ex.retryable()); + assertTrue(ex.idempotent()); + assertSame(cause, ex.getCause()); + } finally { + verify(exceptionMock); + } } } diff --git a/gcloud-java-storage/src/main/java/com/google/cloud/storage/StorageException.java b/gcloud-java-storage/src/main/java/com/google/cloud/storage/StorageException.java index d6333c5c24e3..e0dcd8df0946 100644 --- a/gcloud-java-storage/src/main/java/com/google/cloud/storage/StorageException.java +++ b/gcloud-java-storage/src/main/java/com/google/cloud/storage/StorageException.java @@ -31,7 +31,7 @@ * @see Google Cloud * Storage error codes */ -public class StorageException extends BaseServiceException { +public final class StorageException extends BaseServiceException { // see: https://cloud.google.com/storage/docs/resumable-uploads-xml#practices private static final Set RETRYABLE_ERRORS = ImmutableSet.of( @@ -46,7 +46,11 @@ public class StorageException extends BaseServiceException { private static final long serialVersionUID = -4168430271327813063L; public StorageException(int code, String message) { - super(code, message, null, true); + this(code, message, null); + } + + public StorageException(int code, String message, Throwable cause) { + super(code, message, null, true, cause); } public StorageException(IOException exception) { @@ -71,6 +75,6 @@ protected Set retryableErrors() { */ static StorageException translateAndThrow(RetryHelperException ex) { BaseServiceException.translateAndPropagateIfPossible(ex); - throw new StorageException(UNKNOWN_CODE, ex.getMessage()); + throw new StorageException(UNKNOWN_CODE, ex.getMessage(), ex.getCause()); } } diff --git a/gcloud-java-storage/src/test/java/com/google/cloud/storage/StorageExceptionTest.java b/gcloud-java-storage/src/test/java/com/google/cloud/storage/StorageExceptionTest.java index a562ec1194c9..1f16ff04cee3 100644 --- a/gcloud-java-storage/src/test/java/com/google/cloud/storage/StorageExceptionTest.java +++ b/gcloud-java-storage/src/test/java/com/google/cloud/storage/StorageExceptionTest.java @@ -23,6 +23,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; import com.google.api.client.googleapis.json.GoogleJsonError; @@ -93,7 +94,7 @@ public void testStorageException() { assertNull(exception.getMessage()); assertTrue(exception.retryable()); assertTrue(exception.idempotent()); - assertEquals(cause, exception.getCause()); + assertSame(cause, exception.getCause()); GoogleJsonError error = new GoogleJsonError(); error.setCode(503); @@ -103,11 +104,19 @@ public void testStorageException() { assertEquals("message", exception.getMessage()); assertTrue(exception.retryable()); assertTrue(exception.idempotent()); + + exception = new StorageException(400, "message", cause); + assertEquals(400, exception.code()); + assertEquals("message", exception.getMessage()); + assertNull(exception.reason()); + assertFalse(exception.retryable()); + assertTrue(exception.idempotent()); + assertSame(cause, exception.getCause()); } @Test public void testTranslateAndThrow() throws Exception { - StorageException cause = new StorageException(503, "message"); + Exception cause = new StorageException(503, "message"); RetryHelperException exceptionMock = createMock(RetryHelperException.class); expect(exceptionMock.getCause()).andReturn(cause).times(2); replay(exceptionMock); @@ -121,5 +130,21 @@ public void testTranslateAndThrow() throws Exception { } finally { verify(exceptionMock); } + cause = new IllegalArgumentException("message"); + exceptionMock = createMock(RetryHelperException.class); + expect(exceptionMock.getMessage()).andReturn("message").times(1); + expect(exceptionMock.getCause()).andReturn(cause).times(2); + replay(exceptionMock); + try { + StorageException.translateAndThrow(exceptionMock); + } catch (BaseServiceException ex) { + assertEquals(StorageException.UNKNOWN_CODE, ex.code()); + assertEquals("message", ex.getMessage()); + assertFalse(ex.retryable()); + assertTrue(ex.idempotent()); + assertSame(cause, ex.getCause()); + } finally { + verify(exceptionMock); + } } }