下面列出了怎么用com.google.protobuf.Value的API类实例代码及写法,或者点击链接到github查看源代码。
@Test
public void itReadsNestedListValues() throws IOException {
String json = "{\"listValue\":[[\"nested\"]]}";
HasListValue message = camelCase().readValue(json, HasListValue.class);
assertThat(message.hasListValue()).isTrue();
assertThat(message.getListValue().getValuesList()).hasSize(1);
Value value = message.getListValue().getValues(0);
ListValue list = ListValue.newBuilder().addValues(Value.newBuilder().setStringValue("nested")).build();
switch (value.getKindCase()) {
case LIST_VALUE:
assertThat(value.getListValue()).isEqualToComparingFieldByField(list);
break;
default:
fail("Unexpected value kind: " + value.getKindCase());
}
}
@Test
public void itReadsListValue() throws IOException {
String json = "{\"value\":[\"test\"]}";
HasValue valueWrapper = camelCase().readValue(json, HasValue.class);
assertThat(valueWrapper.hasValue()).isTrue();
Value value = valueWrapper.getValue();
ListValue list = ListValue.newBuilder().addValues(Value.newBuilder().setStringValue("test").build()).build();
switch (value.getKindCase()) {
case LIST_VALUE:
assertThat(value.getListValue()).isEqualTo(list);
break;
default:
fail("Unexpected value kind: " + value.getKindCase());
}
}
@Test
public void itReadsAllStructValueTypes() throws IOException {
String json = "{\"struct\":{\"null\":null,\"number\":1.5,\"string\":\"test\",\"boolean\":true,\"struct\":{\"key\":\"nested\"},\"list\":[\"nested\"]}}";
HasStruct message = camelCase().readValue(json, HasStruct.class);
assertThat(message.hasStruct()).isTrue();
Map<String, Value> map = message.getStruct().getFieldsMap();
Value nested = Value.newBuilder().setStringValue("nested").build();
Struct nestedStruct = Struct.newBuilder().putFields("key", nested).build();
ListValue list = ListValue.newBuilder().addValues(nested).build();
assertThat(map.size()).isEqualTo(6);
assertThat(map.get("null")).isEqualTo(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build());
assertThat(map.get("number")).isEqualTo(Value.newBuilder().setNumberValue(1.5).build());
assertThat(map.get("string")).isEqualTo(Value.newBuilder().setStringValue("test").build());
assertThat(map.get("boolean")).isEqualTo(Value.newBuilder().setBoolValue(true).build());
assertThat(map.get("struct")).isEqualTo(Value.newBuilder().setStructValue(nestedStruct).build());
assertThat(map.get("list")).isEqualTo(Value.newBuilder().setListValue(list).build());
}
/**
* Setup.
*/
@BeforeEach
public void setup() {
this.resultSetMetadata =
ResultSetMetadata.newBuilder()
.setRowType(
StructType.newBuilder().addFields(
Field.newBuilder()
.setName("first_column")
.setType(Type.newBuilder().setCode(TypeCode.STRING))))
.build();
SpannerRowMetadata metadata = new SpannerRowMetadata(this.resultSetMetadata);
this.resultSet = Flux
.just(new SpannerRow(
Collections.singletonList(Value.newBuilder().setStringValue("key1").build()),
metadata),
new SpannerRow(
Collections.singletonList(Value.newBuilder().setStringValue("key2").build()),
metadata));
}
@Override
public List<Dataset> getDatasets(String key, String value, UserInfo userInfo)
throws InvalidProtocolBufferException {
FindDatasets findDatasets =
FindDatasets.newBuilder()
.addPredicates(
KeyValueQuery.newBuilder()
.setKey(key)
.setValue(Value.newBuilder().setStringValue(value).build())
.setOperator(OperatorEnum.Operator.EQ)
.setValueType(ValueTypeEnum.ValueType.STRING)
.build())
.build();
DatasetPaginationDTO datasetPaginationDTO =
findDatasets(findDatasets, userInfo, DatasetVisibility.PRIVATE);
LOGGER.debug("Datasets size is {}", datasetPaginationDTO.getDatasets().size());
return datasetPaginationDTO.getDatasets();
}
@Test
public void itWritesMixedListValue() throws IOException {
Value nestedValue = Value.newBuilder().setStringValue("nested").build();
Struct struct = Struct.newBuilder().putFields("key", nestedValue).build();
ListValue nestedList = ListValue.newBuilder().addValues(nestedValue).build();
ListValue list = ListValue
.newBuilder()
.addValues(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build())
.addValues(Value.newBuilder().setNumberValue(1.5d).build())
.addValues(Value.newBuilder().setStringValue("test").build())
.addValues(Value.newBuilder().setBoolValue(true).build())
.addValues(Value.newBuilder().setStructValue(struct).build())
.addValues(Value.newBuilder().setListValue(nestedList).build())
.build();
HasValue message = HasValue
.newBuilder()
.setValue(Value.newBuilder().setListValue(list).build())
.build();
String json = camelCase().writeValueAsString(message);
assertThat(json).isEqualTo("{\"value\":[null,1.5,\"test\",true,{\"key\":\"nested\"},[\"nested\"]]}");
}
@Override
public List<Project> getProjects(String key, String value, UserInfo userInfo)
throws InvalidProtocolBufferException {
FindProjects findProjects =
FindProjects.newBuilder()
.addPredicates(
KeyValueQuery.newBuilder()
.setKey(key)
.setValue(Value.newBuilder().setStringValue(value).build())
.setOperator(OperatorEnum.Operator.EQ)
.setValueType(ValueTypeEnum.ValueType.STRING)
.build())
.build();
ProjectPaginationDTO projectPaginationDTO =
findProjects(findProjects, null, userInfo, ProjectVisibility.PRIVATE);
LOGGER.debug("Projects size is {}", projectPaginationDTO.getProjects().size());
return projectPaginationDTO.getProjects();
}
/** Convert a Struct to an ImmutableMap. */
public static ImmutableMap<String, Object> toMap(Struct struct) {
return struct
.getFieldsMap()
.entrySet()
.stream()
.collect(
ImmutableMap.toImmutableMap(
entry -> entry.getKey(),
entry -> {
Value value = entry.getValue();
switch (value.getKindCase()) {
case STRUCT_VALUE:
return toMap(value.getStructValue());
case LIST_VALUE:
return toList(value.getListValue());
default:
return getScalarValue(value);
}
}));
}
@Override
public void doMerge(JsonParser parser, int currentDepth, Message.Builder messageBuilder)
throws IOException {
Value.Builder builder = (Value.Builder) messageBuilder;
JsonToken token = parser.currentToken();
if (token.isBoolean()) {
builder.setBoolValue(ParseSupport.parseBool(parser));
} else if (token.isNumeric()) {
builder.setNumberValue(ParseSupport.parseDouble(parser));
} else if (token == JsonToken.VALUE_NULL) {
builder.setNullValue(NullValue.NULL_VALUE);
} else if (token.isScalarValue()) {
builder.setStringValue(ParseSupport.parseString(parser));
} else if (token == JsonToken.START_OBJECT) {
Struct.Builder structBuilder = builder.getStructValueBuilder();
StructMarshaller.INSTANCE.mergeValue(parser, currentDepth + 1, structBuilder);
} else if (token == JsonToken.START_ARRAY) {
ListValue.Builder listValueBuilder = builder.getListValueBuilder();
ListValueMarshaller.INSTANCE.mergeValue(parser, currentDepth + 1, listValueBuilder);
} else {
throw new IllegalStateException("Unexpected json data: " + parser.getText());
}
}
@Override
public void doWrite(Value message, JsonGenerator gen) throws IOException {
switch (message.getKindCase()) {
case NULL_VALUE:
SerializeSupport.printNull(0, gen);
break;
case NUMBER_VALUE:
SerializeSupport.printDouble(message.getNumberValue(), gen);
break;
case STRING_VALUE:
SerializeSupport.printString(message.getStringValue(), gen);
break;
case BOOL_VALUE:
SerializeSupport.printBool(message.getBoolValue(), gen);
break;
case STRUCT_VALUE:
StructMarshaller.INSTANCE.writeValue(message.getStructValue(), gen);
break;
case LIST_VALUE:
ListValueMarshaller.INSTANCE.writeValue(message.getListValue(), gen);
break;
case KIND_NOT_SET:
SerializeSupport.printNull(0, gen);
break;
}
}
@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());
}
private static LoadStatsRequest buildInitialRequest() {
return
LoadStatsRequest.newBuilder()
.setNode(
Node.newBuilder()
.setId("LRS test")
.setMetadata(
Struct.newBuilder()
.putFields(
"TRAFFICDIRECTOR_NETWORK_HOSTNAME",
Value.newBuilder().setStringValue("default").build())
.putFields(
LoadReportClient.TARGET_NAME_METADATA_KEY,
Value.newBuilder().setStringValue(TARGET_NAME).build())))
.build();
}
public EventExecution fromProto(EventExecutionPb.EventExecution from) {
EventExecution to = new EventExecution();
to.setId( from.getId() );
to.setMessageId( from.getMessageId() );
to.setName( from.getName() );
to.setEvent( from.getEvent() );
to.setCreated( from.getCreated() );
to.setStatus( fromProto( from.getStatus() ) );
to.setAction( fromProto( from.getAction() ) );
Map<String, Object> outputMap = new HashMap<String, Object>();
for (Map.Entry<String, Value> pair : from.getOutputMap().entrySet()) {
outputMap.put( pair.getKey(), fromProto( pair.getValue() ) );
}
to.setOutput(outputMap);
return to;
}
public EventHandler.StartWorkflow fromProto(EventHandlerPb.EventHandler.StartWorkflow from) {
EventHandler.StartWorkflow to = new EventHandler.StartWorkflow();
to.setName( from.getName() );
to.setVersion( from.getVersion() );
to.setCorrelationId( from.getCorrelationId() );
Map<String, Object> inputMap = new HashMap<String, Object>();
for (Map.Entry<String, Value> pair : from.getInputMap().entrySet()) {
inputMap.put( pair.getKey(), fromProto( pair.getValue() ) );
}
to.setInput(inputMap);
if (from.hasInputMessage()) {
to.setInputMessage( fromProto( from.getInputMessage() ) );
}
to.setTaskToDomain( from.getTaskToDomainMap() );
return to;
}
public TaskDef fromProto(TaskDefPb.TaskDef from) {
TaskDef to = new TaskDef();
to.setName( from.getName() );
to.setDescription( from.getDescription() );
to.setRetryCount( from.getRetryCount() );
to.setTimeoutSeconds( from.getTimeoutSeconds() );
to.setInputKeys( from.getInputKeysList().stream().collect(Collectors.toCollection(ArrayList::new)) );
to.setOutputKeys( from.getOutputKeysList().stream().collect(Collectors.toCollection(ArrayList::new)) );
to.setTimeoutPolicy( fromProto( from.getTimeoutPolicy() ) );
to.setRetryLogic( fromProto( from.getRetryLogic() ) );
to.setRetryDelaySeconds( from.getRetryDelaySeconds() );
to.setResponseTimeoutSeconds( from.getResponseTimeoutSeconds() );
to.setConcurrentExecLimit( from.getConcurrentExecLimit() );
Map<String, Object> inputTemplateMap = new HashMap<String, Object>();
for (Map.Entry<String, Value> pair : from.getInputTemplateMap().entrySet()) {
inputTemplateMap.put( pair.getKey(), fromProto( pair.getValue() ) );
}
to.setInputTemplate(inputTemplateMap);
to.setRateLimitPerFrequency( from.getRateLimitPerFrequency() );
to.setRateLimitFrequencyInSeconds( from.getRateLimitFrequencyInSeconds() );
to.setIsolationGroupId( from.getIsolationGroupId() );
to.setExecutionNameSpace( from.getExecutionNameSpace() );
to.setOwnerEmail( from.getOwnerEmail() );
to.setPollTimeoutSeconds( from.getPollTimeoutSeconds() );
return to;
}
@Test
public void itReadsMixedListValue() throws IOException {
String json = "{\"value\":[null,1.5,\"test\",true,{\"key\":\"nested\"},[\"nested\"]]}";
HasValue message = camelCase().readValue(json, HasValue.class);
assertThat(message.hasValue()).isTrue();
Value value = message.getValue();
switch (value.getKindCase()) {
case LIST_VALUE:
ListValue list = value.getListValue();
Value nested = Value.newBuilder().setStringValue("nested").build();
Struct struct = Struct.newBuilder().putFields("key", nested).build();
ListValue nestedList = ListValue.newBuilder().addValues(nested).build();
assertThat(list.getValuesCount()).isEqualTo(6);
assertThat(list.getValues(0)).isEqualTo(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build());
assertThat(list.getValues(1)).isEqualTo(Value.newBuilder().setNumberValue(1.5).build());
assertThat(list.getValues(2)).isEqualTo(Value.newBuilder().setStringValue("test").build());
assertThat(list.getValues(3)).isEqualTo(Value.newBuilder().setBoolValue(true).build());
assertThat(list.getValues(4)).isEqualTo(Value.newBuilder().setStructValue(struct).build());
assertThat(list.getValues(5)).isEqualTo(Value.newBuilder().setListValue(nestedList).build());
break;
default:
fail("Unexpected value kind: " + value.getKindCase());
}
}
private static Value createTypedValue(VCFHeaderLineType type, Object value) {
if (type == VCFHeaderLineType.Flag) {
return Value.newBuilder().setBoolValue((Boolean) value).build();
}
// Booleans are given as Boolean objects. Strangely, Floats and Integers
// are given as String objects by HTSJDK.
if (!(value instanceof String)) {
throw new IllegalStateException("Received non-Boolean, non-List type in non-String format. "
+ "This is most likely due to a change in htsjdk's library.");
}
String stringValue = (String) value;
boolean isNumeric = stringValue.matches("[-+]?\\d+(\\.\\d+)?");
if (type == VCFHeaderLineType.Integer && isNumeric) {
return Value.newBuilder().setNumberValue(Integer.parseInt(stringValue)).build();
}
if (type == VCFHeaderLineType.Float && isNumeric) {
return Value.newBuilder().setNumberValue(Double.parseDouble(stringValue)).build();
}
return Value.newBuilder().setStringValue(stringValue).build();
}
public static List<KeyValueQuery> getKeyValueQueriesByWorkspaceDTO(WorkspaceDTO workspaceDTO) {
List<KeyValueQuery> workspaceQueries = new ArrayList<>();
if (workspaceDTO != null && workspaceDTO.getWorkspaceId() != null) {
KeyValueQuery workspacePredicates =
KeyValueQuery.newBuilder()
.setKey(ModelDBConstants.WORKSPACE)
.setValue(Value.newBuilder().setStringValue(workspaceDTO.getWorkspaceId()).build())
.setOperator(OperatorEnum.Operator.EQ)
.setValueType(ValueTypeEnum.ValueType.STRING)
.build();
workspaceQueries.add(workspacePredicates);
KeyValueQuery workspaceTypePredicates =
KeyValueQuery.newBuilder()
.setKey(ModelDBConstants.WORKSPACE_TYPE)
.setValue(
Value.newBuilder()
.setNumberValue(workspaceDTO.getWorkspaceType().getNumber())
.build())
.setOperator(OperatorEnum.Operator.EQ)
.setValueType(ValueTypeEnum.ValueType.NUMBER)
.build();
workspaceQueries.add(workspaceTypePredicates);
}
return workspaceQueries;
}
@Test
public void itWritesNullValue() throws IOException {
HasValue message = HasValue
.newBuilder()
.setValue(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build())
.build();
String json = camelCase().writeValueAsString(message);
assertThat(json).isEqualTo("{\"value\":null}");
}
/** Validate check for protobuf struct type in KeyValueQuery not implemented */
@Test
public void findProjectStructTypeNotImplemented() {
LOGGER.info(
"check for protobuf struct type in KeyValueQuery not implemented test start................................");
// Validate check for struct Type not implemented
List<KeyValueQuery> predicates = new ArrayList<>();
Value numValue = Value.newBuilder().setNumberValue(17.1716586149719).build();
Struct.Builder struct = Struct.newBuilder();
struct.putFields("number_value", numValue);
struct.build();
Value structValue = Value.newBuilder().setStructValue(struct).build();
KeyValueQuery keyValueQuery =
KeyValueQuery.newBuilder()
.setKey("attributes.attribute_1")
.setValue(structValue)
.setOperator(OperatorEnum.Operator.LTE)
.build();
predicates.add(keyValueQuery);
FindProjects findProjects =
FindProjects.newBuilder()
.addProjectIds(project1.getId())
.addAllPredicates(predicates)
.build();
try {
projectServiceStub.findProjects(findProjects);
fail();
} catch (StatusRuntimeException exc) {
Status status = Status.fromThrowable(exc);
assertEquals(Status.UNIMPLEMENTED.getCode(), status.getCode());
}
LOGGER.info(
"check for protobuf struct type in KeyValueQuery not implemented test stop................................");
}
@Override
Value doEncode(A[] value) {
Builder builder = ListValue.newBuilder();
for (A val : value) {
builder.addValues(this.codecs.encode(val));
}
return Value.newBuilder().setListValue(builder.build()).build();
}
static Object decodeValue(Type fieldType, com.google.protobuf.Value proto) {
if (proto.getKindCase() == KindCase.NULL_VALUE) {
return null;
}
switch (fieldType.getCode()) {
case BOOL:
checkType(fieldType, proto, KindCase.BOOL_VALUE);
return parseBoolean(proto);
case INT64:
checkType(fieldType, proto, KindCase.STRING_VALUE);
return parseLong(proto);
case FLOAT64:
return valueProtoToFloat64(proto);
case STRING:
checkType(fieldType, proto, KindCase.STRING_VALUE);
return proto.getStringValue();
case BYTES:
checkType(fieldType, proto, KindCase.STRING_VALUE);
return parseBytes(proto);
case TIMESTAMP:
checkType(fieldType, proto, KindCase.STRING_VALUE);
return parseTimestamp(proto);
case DATE:
checkType(fieldType, proto, KindCase.STRING_VALUE);
return parseDate(proto);
case ARRAY:
checkType(fieldType, proto, KindCase.LIST_VALUE);
ListValue listValue = proto.getListValue();
return decodeArrayValue(fieldType.getArrayElementType(), listValue);
default:
throw new AssertionError("Unhandled type code: " + fieldType.getCode());
}
}
/** Validate check for protobuf struct type in KeyValueQuery not implemented */
@Test
public void findExperimentsStructTypeNotImplemented() {
LOGGER.info(
"Check for protobuf struct type in KeyValueQuery not implemented in findExperiments test start........");
// Validate check for struct Type not implemented
List<KeyValueQuery> predicates = new ArrayList<>();
Value numValue = Value.newBuilder().setNumberValue(17.1716586149719).build();
Struct.Builder struct = Struct.newBuilder();
struct.putFields("number_value", numValue);
struct.build();
Value structValue = Value.newBuilder().setStructValue(struct).build();
KeyValueQuery keyValueQuery =
KeyValueQuery.newBuilder()
.setKey("attributes.attribute_1")
.setValue(structValue)
.setOperator(OperatorEnum.Operator.LTE)
.build();
predicates.add(keyValueQuery);
FindExperiments findExperiments =
FindExperiments.newBuilder()
.setProjectId(project1.getId())
.addAllPredicates(predicates)
.build();
try {
experimentServiceStub.findExperiments(findExperiments);
fail();
} catch (StatusRuntimeException exc) {
Status status = Status.fromThrowable(exc);
assertEquals(Status.UNIMPLEMENTED.getCode(), status.getCode());
}
LOGGER.info(
"Check for protobuf struct type in KeyValueQuery not implemented in findExperiments test stop........");
}
private static void checkType(
Type fieldType, com.google.protobuf.Value proto, KindCase expected) {
if (proto.getKindCase() != expected) {
throw new IllegalArgumentException(
"Invalid value for column type "
+ fieldType
+ " expected "
+ expected
+ " but was "
+ proto.getKindCase());
}
}
@Override
public <T> T get(int columnIndex, Class<T> returnType) {
Value spannerValue = this.values.get(columnIndex);
Type spannerType = (Type) this.rowMetadata.getColumnMetadata(columnIndex)
.getNativeTypeMetadata();
T decodedValue = codecs.decode(spannerValue, spannerType, returnType);
return decodedValue;
}
/**
* Assembles as many complete rows as possible, given previous incomplete fields and a new {@link
* PartialResultSet}.
*
* @param partialResultSet a not yet processed result set
*
* @return the resulting rows from the input {@link PartialResultSet}.
*/
public List<SpannerRow> emitRows(PartialResultSet partialResultSet) {
if (partialResultSet.getValuesList().isEmpty()) {
return Collections.emptyList();
}
List<SpannerRow> rows = new ArrayList<>();
ensureMetadataAvailable(partialResultSet);
int availableCount = partialResultSet.getValuesCount();
if (this.prevIsChunk) {
concatFirstIncompletePiece(partialResultSet);
}
/* if there are more values then it means the incomplete piece is complete.
Also, if this PR isn't chunked then it is also complete. */
if (availableCount > 1 || !partialResultSet.getChunkedValue()) {
emitCompleteFirstValue(partialResultSet, rows);
}
emitMiddleWholePieces(partialResultSet, rows, availableCount);
Value lastVal = partialResultSet.getValues(availableCount - 1);
if (!this.prevIsChunk && partialResultSet.getChunkedValue()) {
initializeIncompletePiece(lastVal);
} else if (availableCount > 1 && !partialResultSet.getChunkedValue()) {
appendToRow(lastVal, rows);
}
this.prevIsChunk = partialResultSet.getChunkedValue();
return rows;
}
private void emitCompleteFirstValue(PartialResultSet partialResultSet, List<SpannerRow> rows) {
Value val = this.prevIsChunk ? this.incompletePieceKind == KindCase.STRING_VALUE
? Value.newBuilder().setStringValue((String) this.incompletePiece)
.build()
: Value.newBuilder()
.setListValue(
ListValue.newBuilder()
.addAllValues((List<Value>) this.incompletePiece))
.build()
: partialResultSet.getValues(0);
appendToRow(val, rows);
this.prevIsChunk = false;
}
private void concatFirstIncompletePiece(PartialResultSet partialResultSet) {
Value firstPiece = partialResultSet.getValues(0);
// Concat code from client lib
if (this.incompletePieceKind == KindCase.STRING_VALUE) {
this.incompletePiece = this.incompletePiece + firstPiece.getStringValue();
} else {
concatLists((List<Value>) this.incompletePiece,
firstPiece.getListValue().getValuesList());
}
}
@Test
public void testIndexingIntoColumns() {
SpannerRowMetadata rowMetadata =
createRowMetadata(TypeCode.STRING, TypeCode.INT64, TypeCode.BOOL);
List<Value> rawSpannerRow = createRawSpannerRow("Hello", 25L, true);
SpannerRow row = new SpannerRow(rawSpannerRow, rowMetadata);
assertThat(row.get("column_2", Boolean.class)).isEqualTo(true);
assertThat(row.get("column_0", String.class)).isEqualTo("Hello");
assertThat(row.get(1, Long.class)).isEqualTo(25L);
}
/** Find projects with value of endTime */
@Test
public void findProjectsByProjectEndTimeTest() {
LOGGER.info("FindProjects by project endtime test start................................");
// get project with value of endTime
Value stringValue =
Value.newBuilder().setStringValue(String.valueOf(project4.getDateCreated())).build();
KeyValueQuery keyValueQuery =
KeyValueQuery.newBuilder()
.setKey(ModelDBConstants.DATE_CREATED)
.setValue(stringValue)
.setOperator(OperatorEnum.Operator.EQ)
.build();
FindProjects findProjects =
FindProjects.newBuilder()
.addAllProjectIds(projectMap.keySet())
.addPredicates(keyValueQuery)
.build();
FindProjects.Response response = projectServiceStub.findProjects(findProjects);
LOGGER.info("FindProjects Response : " + response.getProjectsCount());
assertEquals(
"Project count not match with expected project count", 1, response.getProjectsCount());
assertEquals(
"ProjectRun not match with expected projectRun",
project4.getId(),
response.getProjectsList().get(0).getId());
assertEquals(
"Total records count not matched with expected records count",
1,
response.getTotalRecords());
LOGGER.info("FindProjects by project endtime test stop................................");
}