From 59762ab81946c302da73fb977d2244e70ed8a828 Mon Sep 17 00:00:00 2001 From: Andres Robles <15348598+AndresRoblesMX@users.noreply.github.com> Date: Mon, 13 Jan 2020 19:14:51 -0600 Subject: [PATCH] Increasing test coverage for DaprClientGrpcAdapter (#94) --- .../client/DaprClientGrpcAdapterTest.java | 370 ++++++++++++++++++ 1 file changed, 370 insertions(+) diff --git a/sdk/src/test/java/io/dapr/client/DaprClientGrpcAdapterTest.java b/sdk/src/test/java/io/dapr/client/DaprClientGrpcAdapterTest.java index 9125d336b..e860eefc2 100644 --- a/sdk/src/test/java/io/dapr/client/DaprClientGrpcAdapterTest.java +++ b/sdk/src/test/java/io/dapr/client/DaprClientGrpcAdapterTest.java @@ -506,6 +506,376 @@ public class DaprClientGrpcAdapterTest { assertEquals(expectedState, result.block()); } + @Test + public void getStateObjectValueWithOptionsTest() throws IOException { + String etag = "ETag1"; + String key = "key1"; + MyObject expectedValue = new MyObject(1, "The Value"); + StateKeyValue expectedState = buildStateKey(expectedValue, key, etag); + DaprProtos.GetStateResponseEnvelope responseEnvelope = DaprProtos.GetStateResponseEnvelope.newBuilder() + .setData(getAny(expectedValue)) + .setEtag(etag) + .build(); + StateKeyValue keyRequest = buildStateKey(null, key, etag); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + Duration.ofDays(100), 1, StateOptions.RetryPolicy.Pattern.LINEAR); + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(responseEnvelope); + addCallback(settableFuture, callback, directExecutor()); + when(client.getState(any(io.dapr.DaprProtos.GetStateEnvelope.class))) + .thenReturn(settableFuture); + Mono> result = adater.getState(keyRequest, options, MyObject.class); + settableFuture.set(responseEnvelope); + assertEquals(expectedState, result.block()); + } + + @Test + public void getStateObjectValueWithOptionsNoConcurrencyTest() throws IOException { + String etag = "ETag1"; + String key = "key1"; + MyObject expectedValue = new MyObject(1, "The Value"); + StateKeyValue expectedState = buildStateKey(expectedValue, key, etag); + DaprProtos.GetStateResponseEnvelope responseEnvelope = DaprProtos.GetStateResponseEnvelope.newBuilder() + .setData(getAny(expectedValue)) + .setEtag(etag) + .build(); + StateKeyValue keyRequest = buildStateKey(null, key, etag); + StateOptions options = new StateOptions(null, StateOptions.Concurrency.FIRST_WRITE, + new StateOptions.RetryPolicy(Duration.ofDays(100), 1, StateOptions.RetryPolicy.Pattern.LINEAR)); + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(responseEnvelope); + addCallback(settableFuture, callback, directExecutor()); + when(client.getState(any(io.dapr.DaprProtos.GetStateEnvelope.class))) + .thenReturn(settableFuture); + Mono> result = adater.getState(keyRequest, options, MyObject.class); + settableFuture.set(responseEnvelope); + assertEquals(expectedState, result.block()); + } + + @Test(expected = RuntimeException.class) + public void deleteStateExceptionThrowTest() { + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))).thenThrow(RuntimeException.class); + StateKeyValue key = buildStateKey(null, "Key1", "ETag1"); + Mono result = adater.deleteState(key, null); + result.block(); + } + + @Test(expected = RuntimeException.class) + public void deleteStateCallbackExcpetionThrownTest() { + SettableFuture settableFuture = SettableFuture.create(); + RuntimeException ex = new RuntimeException("An Exception"); + MockCallback callback = + new MockCallback(ex); + addCallback(settableFuture, callback, directExecutor()); + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))) + .thenReturn(settableFuture); + StateKeyValue key = buildStateKey(null, "Key1", "ETag1"); + Mono result = adater.deleteState(key, null); + settableFuture.setException(ex); + result.block(); + } + + @Test + public void deleteStateNoOptionsTest() { + String etag = "ETag1"; + String key = "key1"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))) + .thenReturn(settableFuture); + StateKeyValue stateKey = buildStateKey(null, key, etag); + Mono result = adater.deleteState(stateKey, null); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void deleteStateTest() { + String etag = "ETag1"; + String key = "key1"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))) + .thenReturn(settableFuture); + StateKeyValue stateKey = buildStateKey(null, key, etag); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + Duration.ofDays(100), 1, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.deleteState(stateKey, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void deleteStateNoConsistencyTest() { + String etag = "ETag1"; + String key = "key1"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))) + .thenReturn(settableFuture); + StateKeyValue stateKey = buildStateKey(null, key, etag); + StateOptions options = buildStateOptions(null, StateOptions.Concurrency.FIRST_WRITE, + Duration.ofDays(100), 1, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.deleteState(stateKey, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void deleteStateNoConcurrencyTest() { + String etag = "ETag1"; + String key = "key1"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))) + .thenReturn(settableFuture); + StateKeyValue stateKey = buildStateKey(null, key, etag); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, null, + Duration.ofDays(100), 1, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.deleteState(stateKey, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void deleteStateNoRetryPolicyTest() { + String etag = "ETag1"; + String key = "key1"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))) + .thenReturn(settableFuture); + StateKeyValue stateKey = buildStateKey(null, key, etag); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + null, null, null); + Mono result = adater.deleteState(stateKey, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void deleteStateRetryPolicyNoDurationTest() { + String etag = "ETag1"; + String key = "key1"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))) + .thenReturn(settableFuture); + StateKeyValue stateKey = buildStateKey(null, key, etag); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + null, 1, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.deleteState(stateKey, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void deleteStateRetryPolicyNoThresholdTest() { + String etag = "ETag1"; + String key = "key1"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))) + .thenReturn(settableFuture); + StateKeyValue stateKey = buildStateKey(null, key, etag); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + Duration.ofDays(100), null, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.deleteState(stateKey, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void deleteStateRetryPolicyNoPatternTest() { + String etag = "ETag1"; + String key = "key1"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.deleteState(any(io.dapr.DaprProtos.DeleteStateEnvelope.class))) + .thenReturn(settableFuture); + StateKeyValue stateKey = buildStateKey(null, key, etag); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + Duration.ofDays(100), 1, null); + Mono result = adater.deleteState(stateKey, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test(expected = RuntimeException.class) + public void saveStateExceptionThrownTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenThrow(RuntimeException.class); + Mono result = adater.saveState(key, etag, value, null); + result.block(); + } + + @Test(expected = RuntimeException.class) + public void saveStateCallbackExceptionThrownTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + SettableFuture settableFuture = SettableFuture.create(); + RuntimeException ex = new RuntimeException("An Exception"); + MockCallback callback = new MockCallback<>(ex); + addCallback(settableFuture, callback, directExecutor()); + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenReturn(settableFuture); + Mono result = adater.saveState(key, etag, value, null); + settableFuture.setException(ex); + result.block(); + } + + @Test + public void saveStateNoOptionsTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenReturn(settableFuture); + Mono result = adater.saveState(key, etag, value, null); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void saveStateTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenReturn(settableFuture); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + Duration.ofDays(100), 1, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.saveState(key, etag, value, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void saveStateNoConsistencyTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenReturn(settableFuture); + StateOptions options = buildStateOptions(null, StateOptions.Concurrency.FIRST_WRITE, + Duration.ofDays(100), 1, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.saveState(key, etag, value, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void saveStateNoConcurrencyTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenReturn(settableFuture); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, null, + Duration.ofDays(100), 1, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.saveState(key, etag, value, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void saveStateNoRetryPolicyTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenReturn(settableFuture); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + null, null, null); + Mono result = adater.saveState(key, etag, value, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void saveStateRetryPolicyNoDurationTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenReturn(settableFuture); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + null, 1, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.saveState(key, etag, value, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void saveStateRetryPolicyNoThresholdTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenReturn(settableFuture); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + Duration.ofDays(100), null, StateOptions.RetryPolicy.Pattern.LINEAR); + Mono result = adater.saveState(key, etag, value, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + + @Test + public void saveStateRetryPolicyNoPatternTest() { + String key = "key1"; + String etag = "ETag1"; + String value = "State value"; + SettableFuture settableFuture = SettableFuture.create(); + MockCallback callback = new MockCallback<>(Empty.newBuilder().build()); + addCallback(settableFuture, callback, directExecutor()); + when(client.saveState(any(io.dapr.DaprProtos.SaveStateEnvelope.class))).thenReturn(settableFuture); + StateOptions options = buildStateOptions(StateOptions.Consistency.STRONG, StateOptions.Concurrency.FIRST_WRITE, + Duration.ofDays(100), 1, null); + Mono result = adater.saveState(key, etag, value, options); + settableFuture.set(Empty.newBuilder().build()); + result.block(); + assertTrue(callback.wasCalled); + } + private StateKeyValue buildStateKey(T value, String key, String etag) { return new StateKeyValue(value, key, etag); }