[ggj][codegen][test] feat: ServiceClientTest.rpcTest support for paging (#352)

* fix!: refactor field into MethodArgument, add enum/msg flags

* feat: partial isAssignableFrom VaporRef support, enable full-name type usage

* feat: support negative numeric literals

* fix: separate resname tokenizing from class composer

* feat: add per-type default value composer

* feat: add ServiceClientTest.methodExceptionTests codegen

* feat: add rpcExceptionTest for RPCs w/o overloads, support LRO

* feat: ServiceClientTest.rpcExceptionTest support for LRO, streaming

* fix: sorted method args

* feat: add ServiceClientTest.rpcTest for unary and LRO methods

* feat: ServiceClientTest.rpcTest support for paging

* fix: merge master

Author: miraleung

src/main/java/com/google/api/generator/gapic/composer/DefaultValueComposer.java

@@ -282,4 +282,35 @@ static Expr createSimpleOperationBuilderExpr(String name, VariableExpr responseE
         .setReturnType(OPERATION_TYPE)
         .build();
   }
+
+  static Expr createSimplePagedResponse(TypeNode responseType, Expr responseElementVarExpr) {
+    Expr pagedResponseExpr =
+        MethodInvocationExpr.builder()
+            .setStaticReferenceType(responseType)
+            .setMethodName("newBuilder")
+            .build();
+    pagedResponseExpr =
+        MethodInvocationExpr.builder()
+            .setExprReferenceExpr(pagedResponseExpr)
+            .setMethodName("setNextPageToken")
+            .setArguments(ValueExpr.withValue(StringObjectValue.withValue("")))
+            .build();
+    pagedResponseExpr =
+        MethodInvocationExpr.builder()
+            .setExprReferenceExpr(pagedResponseExpr)
+            .setMethodName("addAllResponses")
+            .setArguments(
+                MethodInvocationExpr.builder()
+                    .setStaticReferenceType(
+                        TypeNode.withReference(ConcreteReference.withClazz(Arrays.class)))
+                    .setMethodName("asList")
+                    .setArguments(responseElementVarExpr)
+                    .build())
+            .build();
+    return MethodInvocationExpr.builder()
+        .setExprReferenceExpr(pagedResponseExpr)
+        .setMethodName("build")
+        .setReturnType(responseType)
+        .build();
+  }
 }

src/main/java/com/google/api/generator/gapic/composer/ServiceClientTestClassComposer.java

@@ -492,27 +492,60 @@ private static MethodDefinition createRpcTestMethod(
     // Construct the expected response.
     // TODO(miraleung): Paging here.
     TypeNode methodOutputType = method.hasLro() ? method.lro().responseType() : method.outputType();
+    List<Expr> methodExprs = new ArrayList<>();
+
+    TypeNode repeatedResponseType = null;
+    VariableExpr responsesElementVarExpr = null;
+    if (method.isPaged()) {
+      Message methodOutputMessage = messageTypes.get(method.outputType().reference().name());
+      repeatedResponseType = findRepeatedPagedType(methodOutputMessage);
+      Preconditions.checkNotNull(
+          repeatedResponseType,
+          String.format(
+              "No repeated type found for paged method %s with output message type %s",
+              method.name(), methodOutputMessage.name()));
+      responsesElementVarExpr =
+          VariableExpr.withVariable(
+              Variable.builder().setType(repeatedResponseType).setName("responsesElement").build());
+      methodExprs.add(
+          AssignmentExpr.builder()
+              .setVariableExpr(responsesElementVarExpr.toBuilder().setIsDecl(true).build())
+              .setValueExpr(
+                  DefaultValueComposer.createDefaultValue(
+                      Field.builder()
+                          .setType(repeatedResponseType)
+                          .setName("responsesElement")
+                          .setIsMessage(true)
+                          .build()))
+              .build());
+    }
+
     VariableExpr expectedResponseVarExpr =
         VariableExpr.withVariable(
             Variable.builder().setType(methodOutputType).setName("expectedResponse").build());
     Expr expectedResponseValExpr = null;
-    if (messageTypes.containsKey(methodOutputType.reference().name())) {
+    if (method.isPaged()) {
       expectedResponseValExpr =
-          DefaultValueComposer.createSimpleMessageBuilderExpr(
-              messageTypes.get(methodOutputType.reference().name()), resourceNames, messageTypes);
+          DefaultValueComposer.createSimplePagedResponse(
+              method.outputType(), responsesElementVarExpr);
     } else {
-      // Wrap this in a field so we don't have to split the helper into lots of different methods,
-      // or duplicate it for VariableExpr.
-      expectedResponseValExpr =
-          DefaultValueComposer.createDefaultValue(
-              Field.builder()
-                  .setType(methodOutputType)
-                  .setIsMessage(true)
-                  .setName("expectedResponse")
-                  .build());
+      if (messageTypes.containsKey(methodOutputType.reference().name())) {
+        expectedResponseValExpr =
+            DefaultValueComposer.createSimpleMessageBuilderExpr(
+                messageTypes.get(methodOutputType.reference().name()), resourceNames, messageTypes);
+      } else {
+        // Wrap this in a field so we don't have to split the helper into lots of different methods,
+        // or duplicate it for VariableExpr.
+        expectedResponseValExpr =
+            DefaultValueComposer.createDefaultValue(
+                Field.builder()
+                    .setType(methodOutputType)
+                    .setIsMessage(true)
+                    .setName("expectedResponse")
+                    .build());
+      }
     }
 
-    List<Expr> methodExprs = new ArrayList<>();
     methodExprs.add(
         AssignmentExpr.builder()
             .setVariableExpr(expectedResponseVarExpr.toBuilder().setIsDecl(true).build())
@@ -588,7 +621,10 @@ private static MethodDefinition createRpcTestMethod(
     // Call the RPC Java method.
     VariableExpr actualResponseVarExpr =
         VariableExpr.withVariable(
-            Variable.builder().setType(methodOutputType).setName("actualResponse").build());
+            Variable.builder()
+                .setType(methodOutputType)
+                .setName(method.isPaged() ? "pagedListResponse" : "actualResponse")
+                .build());
     Expr rpcJavaMethodInvocationExpr =
         MethodInvocationExpr.builder()
             .setExprReferenceExpr(classMemberVarExprs.get("client"))
@@ -610,12 +646,88 @@ private static MethodDefinition createRpcTestMethod(
             .setVariableExpr(actualResponseVarExpr.toBuilder().setIsDecl(true).build())
             .setValueExpr(rpcJavaMethodInvocationExpr)
             .build());
-    methodExprs.add(
-        MethodInvocationExpr.builder()
-            .setStaticReferenceType(STATIC_TYPES.get("Assert"))
-            .setMethodName("assertEquals")
-            .setArguments(expectedResponseVarExpr, actualResponseVarExpr)
-            .build());
+
+    if (method.isPaged()) {
+      // Assign the resources variaqble.
+      VariableExpr resourcesVarExpr =
+          VariableExpr.withVariable(
+              Variable.builder()
+                  .setType(
+                      TypeNode.withReference(
+                          ConcreteReference.builder()
+                              .setClazz(List.class)
+                              .setGenerics(Arrays.asList(repeatedResponseType.reference()))
+                              .build()))
+                  .setName("resources")
+                  .build());
+      Expr iterateAllExpr =
+          MethodInvocationExpr.builder()
+              .setExprReferenceExpr(actualResponseVarExpr)
+              .setMethodName("iterateAll")
+              .build();
+      Expr resourcesValExpr =
+          MethodInvocationExpr.builder()
+              .setStaticReferenceType(STATIC_TYPES.get("Lists"))
+              .setMethodName("newArrayList")
+              .setArguments(iterateAllExpr)
+              .setReturnType(resourcesVarExpr.type())
+              .build();
+      methodExprs.add(
+          AssignmentExpr.builder()
+              .setVariableExpr(resourcesVarExpr)
+              .setValueExpr(resourcesValExpr)
+              .build());
+
+      // Assert the size is equivalent.
+      methodExprs.add(
+          MethodInvocationExpr.builder()
+              .setStaticReferenceType(STATIC_TYPES.get("Assert"))
+              .setMethodName("assertEquals")
+              .setArguments(
+                  ValueExpr.withValue(
+                      PrimitiveValue.builder().setType(TypeNode.INT).setValue("1").build()),
+                  MethodInvocationExpr.builder()
+                      .setExprReferenceExpr(resourcesVarExpr)
+                      .setMethodName("size")
+                      .setReturnType(TypeNode.INT)
+                      .build())
+              .build());
+
+      // Assert the responses are equivalent.
+      Expr zeroExpr =
+          ValueExpr.withValue(PrimitiveValue.builder().setType(TypeNode.INT).setValue("0").build());
+      Expr expectedPagedResponseExpr =
+          MethodInvocationExpr.builder()
+              .setExprReferenceExpr(expectedResponseVarExpr)
+              .setMethodName("getResponsesList")
+              .build();
+      expectedPagedResponseExpr =
+          MethodInvocationExpr.builder()
+              .setExprReferenceExpr(expectedPagedResponseExpr)
+              .setMethodName("get")
+              .setArguments(zeroExpr)
+              .build();
+      Expr actualPagedResponseExpr =
+          MethodInvocationExpr.builder()
+              .setExprReferenceExpr(resourcesVarExpr)
+              .setMethodName("get")
+              .setArguments(zeroExpr)
+              .build();
+
+      methodExprs.add(
+          MethodInvocationExpr.builder()
+              .setStaticReferenceType(STATIC_TYPES.get("Assert"))
+              .setMethodName("assertEquals")
+              .setArguments(expectedPagedResponseExpr, actualPagedResponseExpr)
+              .build());
+    } else {
+      methodExprs.add(
+          MethodInvocationExpr.builder()
+              .setStaticReferenceType(STATIC_TYPES.get("Assert"))
+              .setMethodName("assertEquals")
+              .setArguments(expectedResponseVarExpr, actualResponseVarExpr)
+              .build());
+    }
     // TODO(miraleung): Empty line here.
 
     // Construct the request checker logic.
@@ -658,7 +770,7 @@ private static MethodDefinition createRpcTestMethod(
 
     VariableExpr actualRequestVarExpr =
         VariableExpr.withVariable(
-            Variable.builder().setType(methodOutputType).setName("actualRequest").build());
+            Variable.builder().setType(method.inputType()).setName("actualRequest").build());
     Expr getFirstRequestExpr =
         MethodInvocationExpr.builder()
             .setExprReferenceExpr(actualRequestsVarExpr)
@@ -669,7 +781,7 @@ private static MethodDefinition createRpcTestMethod(
             .setReturnType(STATIC_TYPES.get("AbstractMessage"))
             .build();
     getFirstRequestExpr =
-        CastExpr.builder().setType(methodOutputType).setExpr(getFirstRequestExpr).build();
+        CastExpr.builder().setType(method.inputType()).setExpr(getFirstRequestExpr).build();
     methodExprs.add(
         AssignmentExpr.builder()
             .setVariableExpr(actualRequestVarExpr.toBuilder().setIsDecl(true).build())
@@ -1437,6 +1549,16 @@ private static TypeNode getCallableType(Method protoMethod) {
         ConcreteReference.builder().setClazz(callableClazz).setGenerics(generics).build());
   }
 
+  private static TypeNode findRepeatedPagedType(Message message) {
+    for (Field field : message.fields()) {
+      if (field.isRepeated() && !field.isMap()) {
+        Reference repeatedGenericRef = field.type().reference().generics().get(0);
+        return TypeNode.withReference(repeatedGenericRef);
+      }
+    }
+    return null;
+  }
+
   private static String getCallableMethodName(Method protoMethod) {
     Preconditions.checkState(
         !protoMethod.stream().equals(Method.Stream.NONE),