Java 类com.google.protobuf.Any 实例源码

@Override
ExternalMessageEnvelope markExternal(ExternalMessage externalMsg) {
    final Any packedEvent = externalMsg.getOriginalMessage();
    final Rejection rejection = AnyPacker.unpack(packedEvent);
    final Rejection.Builder rejectionBuilder = rejection.toBuilder();
    final RejectionContext modifiedContext = rejectionBuilder.getContext()
                                                             .toBuilder()
                                                             .setExternal(true)
                                                             .build();

    final Rejection marked = rejectionBuilder.setContext(modifiedContext)
                                             .build();
    final ExternalMessage result = ExternalMessages.of(marked,
                                                       externalMsg.getBoundedContextName());
    return ExternalMessageEnvelope.of(result, Rejections.getMessage(rejection));
}

@Override
public void writeValue(Any message, JsonGenerator gen) throws IOException {
  if (message.equals(Any.getDefaultInstance())) {
    // Note: empty Any is not indented the same way as an empty message, this is likely an
    // upstream bug.
    gen.writeRaw(": {}");
    return;
  }
  gen.writeStartObject();
  String typeUrl = message.getTypeUrl();
  TypeSpecificMarshaller<?> serializer = marshallerRegistry.findByTypeUrl(typeUrl);
  gen.writeFieldName("@type");
  gen.writeString(typeUrl);
  if (serializer instanceof WellKnownTypeMarshaller) {
    gen.writeFieldName("value");
    serializer.writeValue(message.getValue(), gen);
  } else {
    serializer.doWrite(message.getValue(), gen);
  }
  gen.writeEndObject();
}

@Test
public void anyInMaps() throws Exception {
  TestAny.Builder testAny = TestAny.newBuilder();
  testAny.putAnyMap("int32_wrapper", Any.pack(Int32Value.newBuilder().setValue(123).build()));
  testAny.putAnyMap("int64_wrapper", Any.pack(Int64Value.newBuilder().setValue(456).build()));
  testAny.putAnyMap("timestamp", Any.pack(Timestamps.parse("1969-12-31T23:59:59Z")));
  testAny.putAnyMap("duration", Any.pack(Durations.parse("12345.1s")));
  testAny.putAnyMap("field_mask", Any.pack(FieldMaskUtil.fromString("foo.bar,baz")));
  Value numberValue = Value.newBuilder().setNumberValue(1.125).build();
  Struct.Builder struct = Struct.newBuilder();
  struct.putFields("number", numberValue);
  testAny.putAnyMap("struct", Any.pack(struct.build()));
  Value nullValue = Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build();
  testAny.putAnyMap(
      "list_value",
      Any.pack(ListValue.newBuilder().addValues(numberValue).addValues(nullValue).build()));
  testAny.putAnyMap("number_value", Any.pack(numberValue));
  testAny.putAnyMap("any_value_number", Any.pack(Any.pack(numberValue)));
  testAny.putAnyMap("any_value_default", Any.pack(Any.getDefaultInstance()));
  testAny.putAnyMap("default", Any.getDefaultInstance());

  assertMatchesUpstream(testAny.build(), TestAllTypes.getDefaultInstance());
}

@Override
protected Operation createOperation(Action action) {
  String name = createOperationName(UUID.randomUUID().toString());

  watchers.put(name, new ArrayList<Function<Operation, Boolean>>());

  Digest actionDigest = Digests.computeDigest(action.toByteString());

  ExecuteOperationMetadata metadata = ExecuteOperationMetadata.newBuilder()
      .setActionDigest(actionDigest)
      .build();

  Operation.Builder operationBuilder = Operation.newBuilder()
      .setName(name)
      .setDone(false)
      .setMetadata(Any.pack(metadata));

  return operationBuilder.build();
}

private void requeue(Operation operation) {
  try {
    ExecuteOperationMetadata metadata =
        operation.getMetadata().unpack(ExecuteOperationMetadata.class);

    ExecuteOperationMetadata executingMetadata = metadata.toBuilder()
        .setStage(ExecuteOperationMetadata.Stage.QUEUED)
        .build();

    operation = operation.toBuilder()
        .setMetadata(Any.pack(executingMetadata))
        .build();
    putOperation(operation);
  } catch(InvalidProtocolBufferException ex) {
    // operation is dropped on the floor
  }
}

@Test
@DisplayName("create EventEnricher that defaults absent Task or TaskLabels to default message")
void enricherDefaultsTest() {
    final TaskDraftFinalized eventMsg = TaskDraftFinalized.newBuilder()
                                                          .setTaskId(randomTaskId())
                                                          .build();
    final EventEnvelope envelope = enricher.enrich(of(event(eventMsg)));
    final EventEnvelope enriched = enricher.enrich(envelope);
    final Enrichment enrichment = enriched.getEnrichment();

    final TypeName labelsEnrName = TypeName.from(LabelsListEnrichment.getDescriptor());
    final Any labelIds = enrichment.getContainer()
                                   .getItemsMap()
                                   .get(labelsEnrName.value());
    final LabelsListEnrichment labelIdsEnr = unpack(labelIds);
    assertTrue(labelIdsEnr.getLabelIdsList().getIdsList().isEmpty());

    final TypeName taskTypeName = TypeName.from(TaskEnrichment.getDescriptor());
    final Any task = enrichment.getContainer()
                               .getItemsMap()
                               .get(taskTypeName.value());
    final TaskEnrichment taskEnr = unpack(task);
    assertTrue(isDefault(taskEnr.getTask()));
}

@Test
@DisplayName("create EventEnricher that defaults absent Label to default message")
void moreEnricherDefaultsTest() {
    final LabelledTaskRestored eventMsg = LabelledTaskRestored.newBuilder()
                                                              .setLabelId(randomLabelId())
                                                              .build();
    final EventEnvelope envelope = enricher.enrich(of(event(eventMsg)));
    final EventEnvelope enriched = enricher.enrich(envelope);
    final Enrichment enrichment = enriched.getEnrichment();

    final TypeName enrTypeName = TypeName.from(DetailsEnrichment.getDescriptor());
    final Any packerEnr = enrichment.getContainer()
                                   .getItemsMap()
                                   .get(enrTypeName.value());
    final DetailsEnrichment enr = unpack(packerEnr);
    assertTrue(isDefault(enr.getLabelDetails()));
    assertTrue(isDefault(enr.getTaskDetails()));
}

/**
 * Attempt to unpack if its an any instance. Returns null if not unpacked.
 */
@Nullable private Message maybeUnpackAnyType(FieldDescriptor field, Object value) {
  if (field.getType() == FieldDescriptor.Type.MESSAGE
      && field.getMessageType().getFullName().equals(Any.getDescriptor().getFullName())) {
    Any any = (Any) value;
    Message defaultInstance = anyConverterRegistry.get(any.getTypeUrl());
    if (defaultInstance != null) {
      try {
        return defaultInstance.toBuilder().mergeFrom(any.getValue()).build();
      } catch (InvalidProtocolBufferException e) {
        throw new RuntimeException(e);
      }
    }
  }
  return null;
}

private static MemoizeQueryResponseObserver getDuplicateCostumerStreamObserver() {
    return new MemoizeQueryResponseObserver() {
        @Override
        public void onNext(QueryResponse value) {
            super.onNext(value);

            final List<Any> messages = value.getMessagesList();
            assertFalse(messages.isEmpty());

            final Customer customer = unpack(messages.get(0));
            final Customer sampleCustomer = getSampleCustomer();

            assertEquals(sampleCustomer.getName(), customer.getName());
            assertEquals(sampleCustomer.getNicknamesList(), customer.getNicknamesList());
            assertTrue(customer.hasId());
        }
    };
}

@Nullable
private Set<Any> composeIdPredicate() {
    if (ids == null || ids.isEmpty()) {
        return null;
    }
    final Collection<Any> entityIds = transform(ids, new Function<Object, Any>() {
        @Nullable
        @Override
        public Any apply(@Nullable Object o) {
            checkNotNull(o);
            final Any id = Identifier.pack(o);
            return id;
        }
    });
    final Set<Any> result = newHashSet(entityIds);
    return result;
}

@Test
public void create_topic_for_some_entities_of_kind() {

    final Set<TestEntityId> ids = newHashSet(entityId(1), entityId(2),
                                             entityId(3));
    final Topic topic = factory().topic().someOf(TARGET_ENTITY_CLASS, ids);

    verifyTargetAndContext(topic);

    final List<EntityId> actualIds = topic.getTarget()
                                          .getFilters()
                                          .getIdFilter()
                                          .getIdsList();
    assertEquals(ids.size(), actualIds.size());
    for (EntityId actualId : actualIds) {
        final Any rawId = actualId.getId();
        final TestEntityId unpackedId = AnyPacker.unpack(rawId);
        assertTrue(ids.contains(unpackedId));
    }
}

@Test
public void create_queries_with_param() {
    final String columnName = "myImaginaryColumn";
    final Object columnValue = 42;

    final Query query = factory().query()
                                 .select(TestEntity.class)
                                 .where(eq(columnName, columnValue))
                                 .build();
    assertNotNull(query);
    final Target target = query.getTarget();
    assertFalse(target.getIncludeAll());

    final EntityFilters entityFilters = target.getFilters();
    final List<CompositeColumnFilter> aggregatingColumnFilters = entityFilters.getFilterList();
    assertSize(1, aggregatingColumnFilters);
    final CompositeColumnFilter aggregatingColumnFilter = aggregatingColumnFilters.get(0);
    final Collection<ColumnFilter> columnFilters = aggregatingColumnFilter.getFilterList();
    assertSize(1, columnFilters);
    final Any actualValue = findByName(columnFilters, columnName).getValue();
    assertNotNull(columnValue);
    final Int32Value messageValue = AnyPacker.unpack(actualValue);
    final int actualGenericValue = messageValue.getValue();
    assertEquals(columnValue, actualGenericValue);
}

@Test 
public void testRequestToJSON() throws JsonParseException, IOException, NoSuchMethodException, SecurityException
{
    mockClientConfigHandler.addListener((ClientConfigUpdateListener) EasyMock.anyObject());
    EasyMock.expectLastCall().once();
    replay(mockClientConfigHandler);
    final String client = "test";
    ClientRpcStore store = new ClientRpcStore(mockClientConfigHandler);
    CustomPredictRequest customRequest =  CustomPredictRequest.newBuilder().addData(1.0f).build();
    store.add(client, customRequest.getClass(), null,customRequest.getClass().getMethod("newBuilder"),null);
    Any anyMsg = Any.pack(customRequest);
    ClassificationRequestMeta meta = ClassificationRequestMeta.newBuilder().setPuid("1234").build();
    ClassificationRequest request = ClassificationRequest.newBuilder().setMeta(meta).setData(anyMsg).build();
    JsonNode json = store.getJSONForRequest(client, request);
    Assert.assertNotNull(json);
    System.out.println(json);
    ObjectMapper mapper = new ObjectMapper();
    JsonFactory factory = mapper.getFactory();
    JsonParser parser = factory.createParser(json.toString());
    JsonNode actualObj = mapper.readTree(parser);
    ClassificationRequest req = store.getPredictRequestFromJson(client, actualObj);
    Assert.assertNotNull(req);
}

public static List<Event> toEvents(final Any producerId,
                                   @Nullable final Version version,
                                   final List<? extends Message> eventMessages,
                                   final MessageEnvelope origin) {
    checkNotNull(producerId);
    checkNotNull(eventMessages);
    checkNotNull(origin);

    final EventFactory eventFactory =
            EventFactory.on(origin, producerId);

    return Lists.transform(eventMessages, new Function<Message, Event>() {
        @Override
        public Event apply(@Nullable Message eventMessage) {
            checkNotNull(eventMessage);
            final Event result = eventFactory.createEvent(eventMessage, version);
            return result;
        }
    });
}

@Test
public void not_match_by_wrong_field_name() {
    final String wrongName = "wrong";
    final EntityColumn target = mock(EntityColumn.class);

    final Multimap<EntityColumn, ColumnFilter> filters = of(target,
                                                            eq(wrongName, "any"));
    final CompositeQueryParameter parameter = createParams(filters, EITHER);
    final QueryParameters params = QueryParameters.newBuilder()
                                                  .add(parameter)
                                                  .build();
    final EntityQuery<?> query = createQuery(Collections.emptyList(), params);
    final EntityQueryMatcher<?> matcher = new EntityQueryMatcher<>(query);

    final EntityRecord record = EntityRecord.newBuilder()
                                            .setEntityId(Any.getDefaultInstance())
                                            .build();
    final EntityRecordWithColumns recordWithColumns = of(record);
    assertFalse(matcher.apply(recordWithColumns));
}

/**
 * Routes the first of the messages and returns the message
 * to be associated with the source command.
 *
 * <p>The rest of the messages are stored and those to follow.
 *
 * @return {@code CommandRouted} message with
 * <ul>
 *     <li>the source command,
 *     <li>the first produced command,
 *     <li>the command messages for the commands that will be posted by the router later
 * </ul>
 * @see CommandRouted#getMessageToFollowList()
 */
protected CommandRouted routeFirst() {
    final CommandRouted.Builder result = CommandRouted.newBuilder();
    result.setSource(getSource());

    final Message message = next();
    final Command command = route(message);
    result.addProduced(command);

    final Iterable<Any> iterable = new Iterable<Any>() {
        @Override
        public Iterator<Any> iterator() {
            return AnyPacker.pack(commandMessages());
        }
    };
    result.addAllMessageToFollow(iterable);

    return result.build();
}

/**
 * Obtains the value of the field in the passed object.
 *
 * <p>If the corresponding field is of type {@code Any} it will be unpacked.
 *
 * @return field value or unpacked field value, or
 *         {@code Optional.absent()} if the field is a default {@code Any}
 * @throws IllegalStateException if getting the field value caused an exception.
 *                               The root cause will be available from the thrown instance.
 */
public Optional<Message> getValue(Message object) {
    final Message fieldValue;
    final Message result;
    try {
        fieldValue = (Message) getter.invoke(object);
        if (fieldValue instanceof Any) {
            final Any any = (Any)fieldValue;
            if (isDefault(any)) {
                return Optional.absent();
            }
            result = AnyPacker.unpack(any);
        } else {
            result = fieldValue;
        }
    } catch (IllegalAccessException | InvocationTargetException e) {
        throw illegalStateWithCauseOf(e);
    }

    return Optional.fromNullable(result);
}

private static boolean checkSingleParameter(ColumnFilter filter,
                                            @Nullable MemoizedValue actualValue) {
    if (actualValue == null) {
        return false;
    }
    final Object value;
    final Any wrappedValue = filter.getValue();
    final Class<?> sourceClass = actualValue.getSourceColumn()
                                            .getType();
    if (sourceClass != Any.class) {
        value = toObject(wrappedValue, sourceClass);
    } else {
        value = wrappedValue;
    }
    final boolean result = eval(actualValue.getValue(), filter.getOperator(), value);
    return result;
}

EntityRecord findAndApplyFieldMask(I givenId, FieldMask fieldMask) {
    EntityRecord matchingResult = null;
    for (I recordId : filtered.keySet()) {
        if (recordId.equals(givenId)) {
            final Optional<EntityRecordWithColumns> record = get(recordId);
            if (!record.isPresent()) {
                continue;
            }
            EntityRecord.Builder matchingRecord = record.get()
                                                        .getRecord()
                                                        .toBuilder();
            final Any state = matchingRecord.getState();
            final TypeUrl typeUrl = TypeUrl.parse(state.getTypeUrl());
            final Message wholeState = unpack(state);
            final Message maskedState = applyMask(fieldMask, wholeState, typeUrl);
            final Any processed = pack(maskedState);

            matchingRecord.setState(processed);
            matchingResult = matchingRecord.build();
        }
    }
    return matchingResult;
}

@Override
public ImmutableCollection<Any> process(Query query) {
    final ImmutableList.Builder<Any> resultBuilder = ImmutableList.builder();

    final Target target = query.getTarget();
    final FieldMask fieldMask = query.getFieldMask();

    final Iterator<? extends Entity> entities;
    if (target.getIncludeAll() && fieldMask.getPathsList()
                                           .isEmpty()) {
        entities = repository.loadAll();
    } else {
        final EntityFilters filters = target.getFilters();
        entities = repository.find(filters, fieldMask);
    }
    while (entities.hasNext()) {
        final Entity entity = entities.next();
        final Message state = entity.getState();
        final Any packedState = AnyPacker.pack(state);
        resultBuilder.add(packedState);
    }
    final ImmutableList<Any> result = resultBuilder.build();
    return result;
}

/**
 * Reads a particular set of items from the read-side of the application and
 * feed the result into an instance.
 *
 * <p>{@link Query} defines the query target and the expected detail level for response.
 *
 * <p>The query results are fed to an instance
 * of {@link StreamObserver}&lt;{@link QueryResponse}&gt;.
 *
 * @param query            an instance of query
 * @param responseObserver an observer to feed the query results to.
 */
public void execute(final Query query,
                    final StreamObserver<QueryResponse> responseObserver) {
    queryValidator.validate(query, responseObserver);

    final TypeUrl type = Queries.typeOf(query);
    final QueryProcessor queryProcessor = processorFor(type);

    final QueryOperation op = new QueryOperation(query) {
        @Override
        public void run() {
            final ImmutableCollection<Any> readResult = queryProcessor.process(query());
            final QueryResponse response = QueryResponse.newBuilder()
                                                        .addAllMessages(readResult)
                                                        .setResponse(Responses.ok())
                                                        .build();
            responseObserver.onNext(response);
            responseObserver.onCompleted();
        }
    };
    op.execute();
}

/**
 * Creates the subscribers notification action.
 *
 * <p>The resulting action retrieves the {@linkplain EntityUpdateCallback subscriber callback}
 * and invokes it with the given Entity ID and state.
 *
 * @param subscriptionRecord the attributes of the target subscription
 * @param id                 the ID of the updated Entity
 * @param entityState        the new state of the updated Entity
 * @return a routine delivering the subscription update to the target subscriber
 */
private static Runnable notifySubscriptionAction(final SubscriptionRecord subscriptionRecord,
                                                 final Object id, final Any entityState) {
    final Runnable result = new Runnable() {
        @Override
        public void run() {
            final EntityUpdateCallback callback = subscriptionRecord.getCallback();
            checkNotNull(callback, "Notifying by a non-activated subscription.");
            final Any entityId = toAny(id);
            final EntityStateUpdate stateUpdate = EntityStateUpdate.newBuilder()
                                                                   .setId(entityId)
                                                                   .setState(entityState)
                                                                   .build();
            callback.onStateChanged(stateUpdate);
        }
    };
    return result;
}

@SuppressWarnings("MethodWithMultipleLoops")
@Test
public void read_all_messages_with_field_mask() {
    final List<ProjectId> ids = fillStorage(5);

    final String projectDescriptor = Project.getDescriptor()
                                            .getFullName();
    @SuppressWarnings("DuplicateStringLiteralInspection")       // clashes with non-related tests.
    final FieldMask fieldMask = maskForPaths(projectDescriptor + ".id", projectDescriptor + ".name");

    final Iterator<EntityRecord> read = storage.readAll(fieldMask);
    final Collection<EntityRecord> readRecords = newArrayList(read);
    assertSize(ids.size(), readRecords);
    for (EntityRecord record : readRecords) {
        final Any packedState = record.getState();
        final Project state = AnyPacker.unpack(packedState);
        assertMatchesMask(state, fieldMask);
    }
}

@SuppressWarnings("ConstantConditions") // Converter nullability issues
private List<ProjectId> fillStorage(int count) {
    final List<ProjectId> ids = new LinkedList<>();

    for (int i = 0; i < count; i++) {
        final ProjectId id = newId();
        final Project state = Given.project(id, format("project-%d", i));
        final Any packedState = AnyPacker.pack(state);

        final EntityRecord record = EntityRecord.newBuilder()
                                                .setState(packedState)
                                                .setVersion(
                                                        GivenVersion.withNumber(1))
                                                .build();
        storage.write(id, record);
        ids.add(id);
    }

    return ids;
}

@SuppressWarnings("BreakStatement")
private static Project checkProjectIdIsInList(EntityRecord project, List<ProjectId> ids) {
    final Any packedState = project.getState();
    final Project state = AnyPacker.unpack(packedState);
    final ProjectId id = state.getId();

    boolean isIdPresent = false;
    for (ProjectId genericId : ids) {
        isIdPresent = genericId.equals(id);
        if (isIdPresent) {
            break;
        }
    }
    assertTrue(isIdPresent);

    return state;
}

@Test
public void trigger_subscription_callback_upon_update_of_projection() {
    final Stand stand = prepareStandWithAggregateRepo(mock(StandStorage.class));
    final Topic allProjects = requestFactory.topic().allOf(Project.class);

    final MemoizeEntityUpdateCallback memoizeCallback = new MemoizeEntityUpdateCallback();
    subscribeAndActivate(stand, allProjects, memoizeCallback);
    assertNull(memoizeCallback.newEntityState);

    final Map.Entry<ProjectId, Project> sampleData = fillSampleProjects(1).entrySet()
                                                                          .iterator()
                                                                          .next();
    final ProjectId projectId = sampleData.getKey();
    final Project project = sampleData.getValue();
    final Version stateVersion = GivenVersion.withNumber(1);
    stand.update(asEnvelope(projectId, project, stateVersion));

    final Any packedState = AnyPacker.pack(project);
    assertEquals(packedState, memoizeCallback.newEntityState);
}

@Test
public void not_store_enrichment_for_origin_of_RejectionContext_type() {
    final RejectionContext origin = RejectionContext.newBuilder()
                                                    .setEnrichment(withOneAttribute())
                                                    .build();
    final EventContext context = EventContext.newBuilder()
                                             .setRejectionContext(origin)
                                             .build();
    final Event event = Event.newBuilder()
                             .setId(newEventId())
                             .setContext(context)
                             .setMessage(Any.getDefaultInstance())
                             .build();
    storage.writeEvent(id, event);
    final RejectionContext loadedOrigin = storage.read(newReadRequest(id))
                                                 .get()
                                                 .getEvent(0)
                                                 .getContext()
                                                 .getRejectionContext();
    assertTrue(isDefault(loadedOrigin.getEnrichment()));
}

@Test
public void not_notify_integration_event_subscriber_if_event_is_invalid() {
    final BoundedContext boundedContext = BoundedContext.newBuilder()
                                                        .setMultitenant(true)
                                                        .build();

    // Unsupported message.
    final Any invalidMsg = AnyPacker.pack(BcProjectCreated.getDefaultInstance());
    final IntegrationEvent event =
            Given.AnIntegrationEvent.projectCreated()
                                    .toBuilder()
                                    .setMessage(invalidMsg)
                                    .build();

    final MemoizingObserver<Ack> observer = memoizingObserver();
    boundedContext.notify(event, observer);

    assertEquals(ERROR, observer.firstResponse().getStatus().getStatusCase());
}

@Test
public void retrieve_collection_fields_if_required() {
    requestSampleCustomer(
            new int[]{Customer.NICKNAMES_FIELD_NUMBER - 1},
            new MemoizeQueryResponseObserver() {
                @Override
                public void onNext(QueryResponse value) {
                    super.onNext(value);

                    final List<Any> messages = value.getMessagesList();
                    assertFalse(messages.isEmpty());

                    final Customer sampleCustomer = getSampleCustomer();
                    final Customer customer = unpack(messages.get(0));
                    assertEquals(customer.getNicknamesList(),
                                 sampleCustomer.getNicknamesList());

                    assertFalse(customer.hasName());
                    assertFalse(customer.hasId());
                }
            }
    );
}

@Test
public void convert_type_query_to_EntityFilters() {
    final String typeName = " com.example.EventType ";
    final EventFilter validFilter = filterForType(typeName);
    final EventFilter invalidFilter = filterForType("   ");
    final EventStreamQuery query = EventStreamQuery.newBuilder()
                                                   .addFilter(validFilter)
                                                   .addFilter(invalidFilter)
                                                   .build();
    final EntityFilters entityFilters = toEntityFilters(query);
    assertEquals(1, entityFilters.getFilterCount());

    final CompositeColumnFilter compositeFilter = entityFilters.getFilter(0);
    final List<ColumnFilter> columnFilters = compositeFilter.getFilterList();
    assertEquals(CompositeOperator.EITHER, compositeFilter.getOperator());
    assertEquals(1, columnFilters.size());
    final Any typeNameAsAny = columnFilters.get(0)
                                           .getValue();
    assertEquals(typeName, toObject(typeNameAsAny, String.class));
}

@Test
public void retrieve_all_requested_fields() {
    requestSampleCustomer(
            new int[]{ Customer.NICKNAMES_FIELD_NUMBER - 1,
                    Customer.ID_FIELD_NUMBER - 1 },
            new MemoizeQueryResponseObserver() {
                @Override
                public void onNext(QueryResponse value) {
                    super.onNext(value);

                    final List<Any> messages = value.getMessagesList();
                    assertFalse(messages.isEmpty());

                    final Customer sampleCustomer = getSampleCustomer();
                    final Customer customer = unpack(messages.get(0));
                    assertEquals(customer.getNicknamesList(),
                                 sampleCustomer.getNicknamesList());

                    assertFalse(customer.hasName());
                    assertTrue(customer.hasId());
                }
            }
    );
}

@Test
public void return_CommandRouted_from_routeFirst() throws Exception {
    final CommandRouted commandRouted = router().routeFirst();

    assertSource(commandRouted);

    // Test that only only one command was produced by `routeFirst()`.
    assertEquals(1, commandRouted.getProducedCount());

    // Test that there's only one produced command and it has correct message.
    final Command produced = commandRouted.getProduced(0);
    final StringValue commandMessage = Commands.getMessage(produced);
    assertEquals(messages().get(0), commandMessage);

    assertActorAndTenant(produced);

    // Test that the event contains messages to follow.
    assertEquals(messages().size() - 1, commandRouted.getMessageToFollowCount());

    final List<Any> messageToFollow = commandRouted.getMessageToFollowList();
    assertArrayEquals(messages().subList(1, messages().size()).toArray(),
                      unpackAll(messageToFollow).toArray());
}

@Override
public void doMerge(JsonParser parser, int currentDepth, Message.Builder messageBuilder)
    throws IOException {
  JsonToken token = parser.nextValue();
  if (token == JsonToken.END_OBJECT) {
    return;
  }
  Any.Builder builder = (Any.Builder) messageBuilder;
  if (!parser.getCurrentName().equals("@type")) {
    throw new InvalidProtocolBufferException(
        "MessageMarshaller requires @type to must be the "
            + "first field of an Any. If you need to support @type in any location, use "
            + "upstream JsonFormat. Found: "
            + parser.getText());
  }
  String typeUrl = ParseSupport.parseString(parser);
  TypeSpecificMarshaller<?> contentMarshaller = marshallerRegistry.findByTypeUrl(typeUrl);
  builder.setTypeUrl(typeUrl);
  if (contentMarshaller instanceof WellKnownTypeMarshaller) {
    parser.nextValue();
    if (parser.getCurrentName().equals("value")) {
      builder.setValue(contentMarshaller.readValue(parser, currentDepth).toByteString());
    }
    // Well-known types will not finish parsing the current object (they don't readValue
    // objects),
    // so we close it here.
    if (parser.nextValue() != JsonToken.END_OBJECT) {
      throw new InvalidProtocolBufferException(
          "Expected end of object, got: " + parser.getText());
    }
  } else {
    builder.setValue(
        contentMarshaller
            .parseRemainingFieldsOfObjectAsMessage(parser, currentDepth + 1)
            .toByteString());
  }
}

@Test
public void parserUnexpectedTypeUrl() throws Exception {
  Any.Builder builder = Any.newBuilder();
  assertThatThrownBy(
          () ->
              mergeFromJson(
                  "{\n"
                      + "  \"@type\": \"type.googleapis.com/json_test.TestAllTypes\",\n"
                      + "  \"optionalInt32\": 12345\n"
                      + "}",
                  builder))
      .isInstanceOf(InvalidProtocolBufferException.class);
}

@Test
public void emptyWrapperTypesInAny() throws Exception {
  Any.Builder builder = Any.newBuilder();
  mergeFromJson(
      "{\n"
          + "  \"@type\": \"type.googleapis.com/google.protobuf.BoolValue\",\n"
          + "  \"value\": false\n"
          + "}\n",
      builder,
      TestAllTypes.getDefaultInstance());
  Any any = builder.build();
  assertEquals(0, any.getValue().size());
}

protected void expireOperation(Operation operation) {
  Action action = expectAction(operation);
  Digest actionDigest = Digests.computeDigest(action);
  // one last chance to get partial information from worker
  ActionResult actionResult = action.getDoNotCache()
      ? null
      : getActionResult(actionDigest);
  boolean cachedResult = actionResult != null;
  if (!cachedResult) {
    actionResult = ActionResult.newBuilder()
        .setExitCode(-1)
        .setStderrRaw(ByteString.copyFromUtf8(
            "[BUILDFARM]: Action timed out with no response from worker"))
        .build();
    if (!action.getDoNotCache()) {
      putActionResult(actionDigest, actionResult);
    }
  }
  putOperation(operation.newBuilder()
      .setDone(true)
      .setMetadata(Any.pack(ExecuteOperationMetadata.newBuilder()
          .setStage(ExecuteOperationMetadata.Stage.COMPLETED)
          .build()))
      .setResponse(Any.pack(ExecuteResponse.newBuilder()
          .setResult(actionResult)
          .setCachedResult(cachedResult)
          .build()))
      .build());
}

@Override
public MyListView getMyListView() {
    final Query query = requestFactory.query()
                                      .all(MyListView.class);
    final List<Any> messages = queryService.read(query)
                                           .getMessagesList();
    return messages.isEmpty()
           ? MyListView.getDefaultInstance()
           : AnyPacker.unpack(messages.get(0));
}

@Override
public List<LabelledTasksView> getLabelledTasksView() {
    final Query query = requestFactory.query()
                                      .all(LabelledTasksView.class);
    final List<Any> messages = queryService.read(query)
                                           .getMessagesList();
    final List<LabelledTasksView> result = messages
            .stream()
            .map(AnyPacker::<LabelledTasksView>unpack)
            .collect(toList());

    return result;
}

@Override
public DraftTasksView getDraftTasksView() {
    final Query query = requestFactory.query()
                                      .all(DraftTasksView.class);
    final List<Any> messages = queryService.read(query)
                                           .getMessagesList();
    return messages.isEmpty()
           ? DraftTasksView.getDefaultInstance()
           : AnyPacker.unpack(messages.get(0));
}

/**
 * Retrieves all the messages of the given type.
 *
 * @param cls the class of the desired messages
 * @param <M> the compile-time type of the desired messages
 * @return all the messages of the given type present in the system
 */
private <M extends Message> List<M> getByType(Class<M> cls) {
    final Query query = requestFactory.query()
                                      .all(cls);
    final List<Any> messages = queryService.read(query)
                                           .getMessagesList();
    final List<M> result = messages.stream()
                                   .map(AnyPacker::<M>unpack)
                                   .collect(toList());
    return result;
}