From 3769813ee80f34eea2680b140e21e61a15bb3949 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Jos=C3=A9=20Herrera=20de=20la=20Garza?= Date: Tue, 31 Dec 2019 15:16:59 -0600 Subject: [PATCH 1/5] Change from unwrapMethodResponse to deserialize, because the response from an actor method is not wrapped in "Data" object Add Unit test for the ActorProxy class --- .../io/dapr/actors/client/ActorProxyImpl.java | 6 +- .../actors/client/ActorProxyImplTest.java | 205 +++++++++++++++++- 2 files changed, 202 insertions(+), 9 deletions(-) diff --git a/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java b/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java index 6e94e07964..3b7d0e9780 100644 --- a/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java +++ b/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java @@ -126,7 +126,11 @@ public Mono invokeActorMethod(String methodName, Object data) { * @return Response object, null or RuntimeException. */ private T unwrap(final String response, Class clazz) { - return this.serializer.unwrapMethodResponse(response, clazz); + try{ + return this.serializer.deserialize(response, clazz); + } catch (IOException e) { + throw new RuntimeException(e); + } } /** diff --git a/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java b/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java index 8c49d664b2..2b3405143c 100644 --- a/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java +++ b/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java @@ -4,18 +4,207 @@ import io.dapr.actors.runtime.ActorStateSerializer; import org.junit.Assert; import org.junit.Test; +import org.mockito.Mockito; +import reactor.core.publisher.Mono; + +import static org.mockito.ArgumentMatchers.anyString; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; public class ActorProxyImplTest { @Test() public void constructorActorProxyTest() { - final ActorProxyHttpAsyncClient actorProxyAsyncClient = (ActorProxyHttpAsyncClient)new ActorProxyClientBuilder().buildAsyncClient(); - final ActorProxyImpl actorProxy= new ActorProxyImpl( - "myActorType", - new ActorId("100"), - new ActorStateSerializer(), - actorProxyAsyncClient); - Assert.assertEquals(actorProxy.getActorId().toString(),"100"); - Assert.assertEquals(actorProxy.getActorType(),"myActorType"); + + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + final ActorStateSerializer serializer = mock(ActorStateSerializer.class); + final ActorProxyImpl actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + serializer, + actorProxyAsyncClient); + Assert.assertEquals(actorProxy.getActorId().toString(), "100"); + Assert.assertEquals(actorProxy.getActorType(), "myActorType"); + } + + @Test() + public void invokeActorMethodWithoutDataWithReturnType() { + + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNull())) + .thenReturn(Mono.just("{\n" + + " \"propertyA\": \"valueA\",\n" + + " \"propertyB\": \"valueB\"\n" + + "}")); + + + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + + Mono result = actorProxy.invokeActorMethod("getData", MyData.class); + MyData myData = result.block(); + Assert.assertNotNull(myData); + Assert.assertEquals("valueA", myData.getPropertyA()); + Assert.assertEquals("valueB", myData.getPropertyB()); + + } + + @Test(expected = RuntimeException.class) + public void invokeActorMethodWithIncorrectReturnType() { + + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNull())) + .thenReturn(Mono.just("{test}")); + + + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + + Mono result = actorProxy.invokeActorMethod("getData", MyData.class); + result.block(); + + + } + + @Test() + public void invokeActorMethodSavingDataWithReturnType() { + + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNotNull())) + .thenReturn(Mono.just("{\n" + + " \"propertyA\": \"valueA\",\n" + + " \"propertyB\": \"valueB\"\n" + + "}")); + + + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + + MyData saveData= new MyData(); + saveData.setPropertyA("valueA"); + saveData.setPropertyB("valueB"); + + Mono result = actorProxy.invokeActorMethod("getData", saveData, MyData.class); + MyData myData = result.block(); + Assert.assertNotNull(myData); + Assert.assertEquals("valueA", myData.getPropertyA()); + Assert.assertEquals("valueB", myData.getPropertyB()); + + } + + @Test(expected = RuntimeException.class) + public void invokeActorMethodSavingDataWithIncorrectReturnType() { + + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNotNull())) + .thenReturn(Mono.just("{test}")); + + + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + + MyData saveData= new MyData(); + saveData.setPropertyA("valueA"); + saveData.setPropertyB("valueB"); + + Mono result = actorProxy.invokeActorMethod("getData", saveData, MyData.class); + MyData myData = result.block(); + Assert.assertNotNull(myData); + Assert.assertEquals("valueA", myData.getPropertyA()); + Assert.assertEquals("valueB", myData.getPropertyB()); + + } + + @Test() + public void invokeActorMethodWithDataWithVoidReturnType() { + + MyData saveData= new MyData(); + saveData.setPropertyA("valueA"); + saveData.setPropertyB("valueB"); + + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNotNull())) + .thenReturn(Mono.empty()); + + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + + + + Mono result = actorProxy.invokeActorMethod("getData", saveData); + Void emptyResponse = result.block(); + Assert.assertNull(emptyResponse); + + } + + @Test() + public void invokeActorMethodWithoutDataWithVoidReturnType() { + + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNull())) + .thenReturn(Mono.empty()); + + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + + Mono result = actorProxy.invokeActorMethod("getData"); + Void emptyResponse = result.block(); + Assert.assertNull(emptyResponse); + + } + + static class MyData { + + /// Gets or sets the value for PropertyA. + private String propertyA; + + /// Gets or sets the value for PropertyB. + private String propertyB; + + + public String getPropertyB() { + return propertyB; + } + + public void setPropertyB(String propertyB) { + this.propertyB = propertyB; + } + + public String getPropertyA() { + return propertyA; + } + + public void setPropertyA(String propertyA) { + this.propertyA = propertyA; + } + + @Override + public String toString() { + return "MyData{" + + "propertyA='" + propertyA + '\'' + + ", propertyB='" + propertyB + '\'' + + '}'; + } + } + } From 6a65a7c4cc864a5e439c777ff71d986cf40313d4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Jos=C3=A9=20Herrera=20de=20la=20Garza?= Date: Thu, 2 Jan 2020 22:27:02 -0600 Subject: [PATCH 2/5] #24 Implement more testing to the ActorProxyImpl and refactor how we manage the errors with Mono #20 Add the coverage tool JaCoCo, the rules are commented at this moment in order to allow to execute the examples at this moment, if we enable the rules, the compilation fails. --- sdk/pom.xml | 49 +++++++ sdk/src/main/java/io/dapr/actors/ActorId.java | 17 +-- .../io/dapr/actors/client/ActorProxyImpl.java | 59 +++++--- .../test/java/io/dapr/actors/ActorIdTest.java | 3 +- .../actors/client/ActorProxyBuilderTest.java | 54 ++++++++ .../actors/client/ActorProxyImplTest.java | 127 +++++++++++++++--- 6 files changed, 248 insertions(+), 61 deletions(-) create mode 100644 sdk/src/test/java/io/dapr/actors/client/ActorProxyBuilderTest.java diff --git a/sdk/pom.xml b/sdk/pom.xml index a55bc782b5..351f0df945 100644 --- a/sdk/pom.xml +++ b/sdk/pom.xml @@ -97,6 +97,55 @@ + + org.jacoco + jacoco-maven-plugin + 0.8.4 + + + default-prepare-agent + + prepare-agent + + + + report + test + + report + + + + check + + check + + + + + + + + + + diff --git a/sdk/src/main/java/io/dapr/actors/ActorId.java b/sdk/src/main/java/io/dapr/actors/ActorId.java index 77a5f235b3..d49e86bc1f 100644 --- a/sdk/src/main/java/io/dapr/actors/ActorId.java +++ b/sdk/src/main/java/io/dapr/actors/ActorId.java @@ -111,22 +111,7 @@ public static ActorId createRandom() { return new ActorId(id.toString()); } - /** - * Determines whether two specified actorIds have the same id. - * - * @param id1 The first actorId to compare, or null - * @param id2 The second actorId to compare, or null. - * @return true if the id is same for both objects; otherwise, false. - */ - private static boolean equals(ActorId id1, ActorId id2) { - if (id1 == null && id2 == null) { - return true; - } else if (id2 == null || id1 == null) { - return false; - } else { - return hasEqualContent(id1, id2); - } - } + /** * Compares if two actors have the same content. diff --git a/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java b/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java index 3b7d0e9780..d1f575657f 100644 --- a/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java +++ b/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java @@ -65,19 +65,29 @@ public String getActorType() { */ @Override public Mono invokeActorMethod(String methodName, Object data, Class clazz) { + String jasonPayload; try { - Mono result = this.daprClient.invokeActorMethod( + jasonPayload = this.wrap(data); + } catch (IOException e) { + return Mono.error(e); + } + + Mono result = this.daprClient.invokeActorMethod( actorType, actorId.toString(), methodName, - this.wrap(data)); + jasonPayload + ); return result - .filter(s -> (s != null) && (!s.isEmpty())) - .map(s -> unwrap(s, clazz)); - } catch (IOException e) { - return Mono.error(e); - } + .filter(s -> !s.isEmpty()) + .flatMap(s -> { + try { + return Mono.just(unwrap(s, clazz)); + } catch (IOException e) { + return Mono.error(e); + } + }); } /** @@ -86,9 +96,15 @@ public Mono invokeActorMethod(String methodName, Object data, Class cl @Override public Mono invokeActorMethod(String methodName, Class clazz) { Mono result = this.daprClient.invokeActorMethod(actorType, actorId.toString(), methodName, null); - return result - .filter(s -> (s != null) && (!s.isEmpty())) - .map(s -> unwrap(s, clazz)); + return result + .filter(s -> !s.isEmpty()) + .flatMap(s -> { + try { + return Mono.just(unwrap(s, clazz)); + } catch (IOException e) { + return Mono.error(e); + } + }); } /** @@ -105,16 +121,19 @@ public Mono invokeActorMethod(String methodName) { */ @Override public Mono invokeActorMethod(String methodName, Object data) { + String jasonPayload; try { - Mono result = this.daprClient.invokeActorMethod( - actorType, - actorId.toString(), - methodName, - this.wrap(data)); - return result.then(); + jasonPayload = this.wrap(data); } catch (IOException e) { return Mono.error(e); } + return this.daprClient.invokeActorMethod( + actorType, + actorId.toString(), + methodName, + jasonPayload).then(); + + } /** @@ -125,12 +144,8 @@ public Mono invokeActorMethod(String methodName, Object data) { * @param Expected response type. * @return Response object, null or RuntimeException. */ - private T unwrap(final String response, Class clazz) { - try{ - return this.serializer.deserialize(response, clazz); - } catch (IOException e) { - throw new RuntimeException(e); - } + private T unwrap(final String response, Class clazz) throws IOException { + return this.serializer.deserialize(response, clazz); } /** diff --git a/sdk/src/test/java/io/dapr/actors/ActorIdTest.java b/sdk/src/test/java/io/dapr/actors/ActorIdTest.java index ab62f0e33b..fe512ae844 100644 --- a/sdk/src/test/java/io/dapr/actors/ActorIdTest.java +++ b/sdk/src/test/java/io/dapr/actors/ActorIdTest.java @@ -46,7 +46,7 @@ public void verifyEqualsByActorId() { List values = createEqualsTestValues(); for (Wrapper w : values) { ActorId a1 = (ActorId) w.item1; - ActorId a2 = (ActorId) w.item2; + Object a2 = w.item2; Assert.assertEquals(w.expectedResult, a1.equals(a2)); } } @@ -65,6 +65,7 @@ private List createEqualsTestValues() { List list = new ArrayList(); list.add(new Wrapper(new ActorId("1"), null, false)); list.add(new Wrapper(new ActorId("1"), new ActorId("1"), true)); + list.add(new Wrapper(new ActorId("1"), new Object(), false)); list.add(new Wrapper(new ActorId("1"), new ActorId("2"), false)); return list; diff --git a/sdk/src/test/java/io/dapr/actors/client/ActorProxyBuilderTest.java b/sdk/src/test/java/io/dapr/actors/client/ActorProxyBuilderTest.java new file mode 100644 index 0000000000..bc91f9a51e --- /dev/null +++ b/sdk/src/test/java/io/dapr/actors/client/ActorProxyBuilderTest.java @@ -0,0 +1,54 @@ +package io.dapr.actors.client; + +import io.dapr.actors.ActorId; +import org.junit.Assert; +import org.junit.Test; + +import static org.junit.Assert.*; + +public class ActorProxyBuilderTest { + + @Test(expected = IllegalArgumentException.class) + public void buildWithNullActorId() { + new ActorProxyBuilder() + .withActorId(null) + .withActorType("test") + .withPort(20) + .build(); + + } + + @Test(expected = IllegalArgumentException.class) + public void buildWithEmptyActorType() { + new ActorProxyBuilder() + .withActorId(new ActorId("100")) + .withActorType("") + .withPort(20) + .build(); + + } + + @Test(expected = IllegalArgumentException.class) + public void buildWithNullActorType() { + new ActorProxyBuilder() + .withActorId(new ActorId("100")) + .withActorType(null) + .withPort(20) + .build(); + + } + + @Test() + public void build() { + ActorProxy actorProxy = new ActorProxyBuilder() + .withActorId(new ActorId("100")) + .withActorType("test") + .withPort(20) + .build(); + + Assert.assertNotNull(actorProxy); + Assert.assertEquals("test",actorProxy.getActorType()); + Assert.assertEquals("100",actorProxy.getActorId().toString()); + + } +} \ No newline at end of file diff --git a/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java b/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java index 2b3405143c..98b5228c4d 100644 --- a/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java +++ b/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java @@ -8,7 +8,6 @@ import reactor.core.publisher.Mono; import static org.mockito.ArgumentMatchers.anyString; - import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; @@ -16,7 +15,6 @@ public class ActorProxyImplTest { @Test() public void constructorActorProxyTest() { - final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); final ActorStateSerializer serializer = mock(ActorStateSerializer.class); final ActorProxyImpl actorProxy = new ActorProxyImpl( @@ -26,12 +24,10 @@ public void constructorActorProxyTest() { actorProxyAsyncClient); Assert.assertEquals(actorProxy.getActorId().toString(), "100"); Assert.assertEquals(actorProxy.getActorType(), "myActorType"); - } @Test() public void invokeActorMethodWithoutDataWithReturnType() { - final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNull())) .thenReturn(Mono.just("{\n" + @@ -39,7 +35,6 @@ public void invokeActorMethodWithoutDataWithReturnType() { " \"propertyB\": \"valueB\"\n" + "}")); - final ActorProxy actorProxy = new ActorProxyImpl( "myActorType", new ActorId("100"), @@ -51,17 +46,31 @@ public void invokeActorMethodWithoutDataWithReturnType() { Assert.assertNotNull(myData); Assert.assertEquals("valueA", myData.getPropertyA()); Assert.assertEquals("valueB", myData.getPropertyB()); + } + @Test() + public void invokeActorMethodWithoutDataWithEmptyReturnType() { + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNull())) + .thenReturn(Mono.just("")); + + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + + Mono result = actorProxy.invokeActorMethod("getData", MyData.class); + MyData myData = result.block(); + Assert.assertNull(myData); } @Test(expected = RuntimeException.class) public void invokeActorMethodWithIncorrectReturnType() { - final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNull())) .thenReturn(Mono.just("{test}")); - final ActorProxy actorProxy = new ActorProxyImpl( "myActorType", new ActorId("100"), @@ -69,14 +78,17 @@ public void invokeActorMethodWithIncorrectReturnType() { actorProxyAsyncClient); Mono result = actorProxy.invokeActorMethod("getData", MyData.class); - result.block(); + + result.doOnSuccess(x -> + Assert.fail("Not exception was throw")) + .doOnError(Throwable::printStackTrace + ).block(); } @Test() public void invokeActorMethodSavingDataWithReturnType() { - final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNotNull())) .thenReturn(Mono.just("{\n" + @@ -84,14 +96,13 @@ public void invokeActorMethodSavingDataWithReturnType() { " \"propertyB\": \"valueB\"\n" + "}")); - final ActorProxy actorProxy = new ActorProxyImpl( "myActorType", new ActorId("100"), new ActorStateSerializer(), actorProxyAsyncClient); - MyData saveData= new MyData(); + MyData saveData = new MyData(); saveData.setPropertyA("valueA"); saveData.setPropertyB("valueB"); @@ -105,11 +116,33 @@ public void invokeActorMethodSavingDataWithReturnType() { @Test(expected = RuntimeException.class) public void invokeActorMethodSavingDataWithIncorrectReturnType() { - final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNotNull())) .thenReturn(Mono.just("{test}")); + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + + MyData saveData = new MyData(); + saveData.setPropertyA("valueA"); + saveData.setPropertyB("valueB"); + + Mono result = actorProxy.invokeActorMethod("getData", saveData, MyData.class); + result.doOnSuccess(x -> + Assert.fail("Not exception was throw")) + .doOnError(Throwable::printStackTrace + ).block(); + + } + + @Test() + public void invokeActorMethodSavingDataWithEmptyReturnType() { + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNotNull())) + .thenReturn(Mono.just("")); final ActorProxy actorProxy = new ActorProxyImpl( "myActorType", @@ -117,22 +150,44 @@ public void invokeActorMethodSavingDataWithIncorrectReturnType() { new ActorStateSerializer(), actorProxyAsyncClient); - MyData saveData= new MyData(); + MyData saveData = new MyData(); saveData.setPropertyA("valueA"); saveData.setPropertyB("valueB"); Mono result = actorProxy.invokeActorMethod("getData", saveData, MyData.class); MyData myData = result.block(); - Assert.assertNotNull(myData); - Assert.assertEquals("valueA", myData.getPropertyA()); - Assert.assertEquals("valueB", myData.getPropertyB()); + Assert.assertNull(myData); + } + + + @Test(expected = RuntimeException.class) + public void invokeActorMethodSavingDataWithIncorrectInputType() { + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNotNull())) + .thenReturn(Mono.just("{test}")); + + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + + MyData saveData = new MyData(); + saveData.setPropertyA("valueA"); + saveData.setPropertyB("valueB"); + saveData.setMyData(saveData); + + Mono result = actorProxy.invokeActorMethod("getData", saveData, MyData.class); + result.doOnSuccess(x -> + Assert.fail("Not exception was throw")) + .doOnError(Throwable::printStackTrace + ).block(); } @Test() public void invokeActorMethodWithDataWithVoidReturnType() { - - MyData saveData= new MyData(); + MyData saveData = new MyData(); saveData.setPropertyA("valueA"); saveData.setPropertyB("valueB"); @@ -146,17 +201,36 @@ public void invokeActorMethodWithDataWithVoidReturnType() { new ActorStateSerializer(), actorProxyAsyncClient); - - Mono result = actorProxy.invokeActorMethod("getData", saveData); Void emptyResponse = result.block(); Assert.assertNull(emptyResponse); + } + + + @Test(expected = RuntimeException.class) + public void invokeActorMethodWithDataWithVoidIncorrectInputType() { + MyData saveData = new MyData(); + saveData.setPropertyA("valueA"); + saveData.setPropertyB("valueB"); + saveData.setMyData(saveData); + + final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); + when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNotNull())) + .thenReturn(Mono.empty()); + + final ActorProxy actorProxy = new ActorProxyImpl( + "myActorType", + new ActorId("100"), + new ActorStateSerializer(), + actorProxyAsyncClient); + Mono result = actorProxy.invokeActorMethod("getData", saveData); + Void emptyResponse = result.doOnError(Throwable::printStackTrace).block(); + Assert.assertNull(emptyResponse); } @Test() public void invokeActorMethodWithoutDataWithVoidReturnType() { - final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNull())) .thenReturn(Mono.empty()); @@ -170,7 +244,6 @@ public void invokeActorMethodWithoutDataWithVoidReturnType() { Mono result = actorProxy.invokeActorMethod("getData"); Void emptyResponse = result.block(); Assert.assertNull(emptyResponse); - } static class MyData { @@ -181,6 +254,8 @@ static class MyData { /// Gets or sets the value for PropertyB. private String propertyB; + private MyData myData; + public String getPropertyB() { return propertyB; @@ -205,6 +280,14 @@ public String toString() { ", propertyB='" + propertyB + '\'' + '}'; } + + public MyData getMyData() { + return myData; + } + + public void setMyData(MyData myData) { + this.myData = myData; + } } } From e839df43196c85995a687d93a5e9c9aa948a6de9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Jos=C3=A9=20Herrera=20de=20la=20Garza?= Date: Sat, 4 Jan 2020 14:20:26 -0600 Subject: [PATCH 3/5] Enable rules for unit test coverage with a minimum of 0 in order to allow the developers to success compile, the minimum should be set to .8 before the projects ends --- sdk/pom.xml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sdk/pom.xml b/sdk/pom.xml index 351f0df945..cb4bc8bc39 100644 --- a/sdk/pom.xml +++ b/sdk/pom.xml @@ -122,24 +122,24 @@ - + From 4b37ecf26e0211603338dfc18eaab1bc5ae5f83f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Juan=20Jos=C3=A9=20Herrera=20de=20la=20Garza?= Date: Sun, 5 Jan 2020 14:42:33 -0600 Subject: [PATCH 4/5] Use the unwrapMethodResponse of the serilizer in order to deserilize actor responses. --- sdk/pom.xml | 7 ++++++- .../main/java/io/dapr/actors/client/ActorProxyImpl.java | 2 +- .../java/io/dapr/actors/client/ActorProxyImplTest.java | 6 ++---- 3 files changed, 9 insertions(+), 6 deletions(-) diff --git a/sdk/pom.xml b/sdk/pom.xml index cb4bc8bc39..650e5ba593 100644 --- a/sdk/pom.xml +++ b/sdk/pom.xml @@ -53,7 +53,9 @@ test - + + true + @@ -88,6 +90,9 @@ org.apache.maven.plugins maven-failsafe-plugin 2.22.2 + + ${skipITs} + diff --git a/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java b/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java index d1f575657f..fbb673aabd 100644 --- a/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java +++ b/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java @@ -145,7 +145,7 @@ public Mono invokeActorMethod(String methodName, Object data) { * @return Response object, null or RuntimeException. */ private T unwrap(final String response, Class clazz) throws IOException { - return this.serializer.deserialize(response, clazz); + return this.serializer.unwrapMethodResponse(response, clazz); } /** diff --git a/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java b/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java index 98b5228c4d..a1c4604cb8 100644 --- a/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java +++ b/sdk/src/test/java/io/dapr/actors/client/ActorProxyImplTest.java @@ -31,8 +31,7 @@ public void invokeActorMethodWithoutDataWithReturnType() { final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNull())) .thenReturn(Mono.just("{\n" + - " \"propertyA\": \"valueA\",\n" + - " \"propertyB\": \"valueB\"\n" + + "\t\"data\": \"ewoJCSJwcm9wZXJ0eUEiOiAidmFsdWVBIiwKCQkicHJvcGVydHlCIjogInZhbHVlQiIKCX0=\"\n" + "}")); final ActorProxy actorProxy = new ActorProxyImpl( @@ -92,8 +91,7 @@ public void invokeActorMethodSavingDataWithReturnType() { final ActorProxyHttpAsyncClient actorProxyAsyncClient = mock(ActorProxyHttpAsyncClient.class); when(actorProxyAsyncClient.invokeActorMethod(anyString(), anyString(), anyString(), Mockito.isNotNull())) .thenReturn(Mono.just("{\n" + - " \"propertyA\": \"valueA\",\n" + - " \"propertyB\": \"valueB\"\n" + + "\t\"data\": \"ewoJCSJwcm9wZXJ0eUEiOiAidmFsdWVBIiwKCQkicHJvcGVydHlCIjogInZhbHVlQiIKCX0=\"\n" + "}")); final ActorProxy actorProxy = new ActorProxyImpl( From 898e8560274d0636a060e74d58fac3ace4701d76 Mon Sep 17 00:00:00 2001 From: Artur Souza Date: Mon, 6 Jan 2020 10:27:42 -0800 Subject: [PATCH 5/5] Reverting ActorProxyImpl.java There is not need to change ActorProxyImpl since the previous change to not wrap it with the "data" structure was incorrect. --- .../io/dapr/actors/client/ActorProxyImpl.java | 57 +++++++------------ 1 file changed, 19 insertions(+), 38 deletions(-) diff --git a/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java b/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java index fbb673aabd..c4877e1046 100644 --- a/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java +++ b/sdk/src/main/java/io/dapr/actors/client/ActorProxyImpl.java @@ -65,29 +65,19 @@ public String getActorType() { */ @Override public Mono invokeActorMethod(String methodName, Object data, Class clazz) { - String jasonPayload; try { - jasonPayload = this.wrap(data); + Mono result = this.daprClient.invokeActorMethod( + actorType, + actorId.toString(), + methodName, + this.wrap(data)); + + return result + .filter(s -> (s != null) && (!s.isEmpty())) + .map(s -> unwrap(s, clazz)); } catch (IOException e) { return Mono.error(e); } - - Mono result = this.daprClient.invokeActorMethod( - actorType, - actorId.toString(), - methodName, - jasonPayload - ); - - return result - .filter(s -> !s.isEmpty()) - .flatMap(s -> { - try { - return Mono.just(unwrap(s, clazz)); - } catch (IOException e) { - return Mono.error(e); - } - }); } /** @@ -96,15 +86,9 @@ public Mono invokeActorMethod(String methodName, Object data, Class cl @Override public Mono invokeActorMethod(String methodName, Class clazz) { Mono result = this.daprClient.invokeActorMethod(actorType, actorId.toString(), methodName, null); - return result - .filter(s -> !s.isEmpty()) - .flatMap(s -> { - try { - return Mono.just(unwrap(s, clazz)); - } catch (IOException e) { - return Mono.error(e); - } - }); + return result + .filter(s -> (s != null) && (!s.isEmpty())) + .map(s -> unwrap(s, clazz)); } /** @@ -121,19 +105,16 @@ public Mono invokeActorMethod(String methodName) { */ @Override public Mono invokeActorMethod(String methodName, Object data) { - String jasonPayload; try { - jasonPayload = this.wrap(data); + Mono result = this.daprClient.invokeActorMethod( + actorType, + actorId.toString(), + methodName, + this.wrap(data)); + return result.then(); } catch (IOException e) { return Mono.error(e); } - return this.daprClient.invokeActorMethod( - actorType, - actorId.toString(), - methodName, - jasonPayload).then(); - - } /** @@ -144,7 +125,7 @@ public Mono invokeActorMethod(String methodName, Object data) { * @param Expected response type. * @return Response object, null or RuntimeException. */ - private T unwrap(final String response, Class clazz) throws IOException { + private T unwrap(final String response, Class clazz) { return this.serializer.unwrapMethodResponse(response, clazz); }