def test_as_datetime(self):
datetime = DateTime()
datetime.year = 123
datetime.month = 2
datetime.day = 1
datetime.hour = 10
datetime.minute = 20
datetime.sec = 10
datetime.microsec = 100
value = ttypes.Value(dtVal=datetime)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_datetime()
datetime_val = value_wrapper.as_datetime()
datetime_val.set_timezone_offset(28800)
assert isinstance(datetime_val, DateTimeWrapper)
assert datetime_val.get_hour() == 10
assert datetime_val.get_minute() == 20
assert datetime_val.get_sec() == 10
assert datetime_val.get_microsec() == 100
assert 'utc datetime: 123-02-01T10:20:10.000100, timezone_offset: 28800' == str(
datetime_val)
assert '123-02-01T18:20:10.000100' == datetime_val.get_local_datetime_str(
)
new_datetime = copy.deepcopy(datetime)
new_datetime.hour = 18
assert new_datetime == datetime_val.get_local_datetime()
new_datetime_2 = copy.deepcopy(datetime)
new_datetime_2.hour = 12
assert new_datetime_2 == datetime_val.get_local_datetime_by_timezone_offset(
7200)
def test_as_time(self):
time = Time()
time.hour = 10
time.minute = 20
time.sec = 10
time.microsec = 100
value = ttypes.Value(tVal=time)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_time()
time_val = value_wrapper.as_time()
time_val.set_timezone_offset(28800)
assert isinstance(time_val, TimeWrapper)
assert time_val.get_hour() == 10
assert time_val.get_minute() == 20
assert time_val.get_sec() == 10
assert time_val.get_microsec() == 100
assert 'utc time: 10:20:10.000100, timezone_offset: 28800' == str(
time_val)
assert '18:20:10.000100' == time_val.get_local_time_str()
new_time = copy.deepcopy(time)
new_time.hour = 18
assert new_time == time_val.get_local_time()
new_time_2 = copy.deepcopy(time)
new_time_2.hour = 12
assert new_time_2 == time_val.get_local_time_by_timezone_offset(7200)
def test_as_int(self):
value = ttypes.Value()
value.set_iVal(100)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_int()
node = value_wrapper.as_int()
assert isinstance(node, int)
def test_as_node(self):
value = ttypes.Value()
value.set_vVal(self.get_vertex_value(b'Tom'))
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_vertex()
node = value_wrapper.as_node()
assert isinstance(node, Node)
def test_as_relationship(self):
value = ttypes.Value()
value.set_eVal(self.get_edge_value(b'Tom', b'Lily'))
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_edge()
relationship = value_wrapper.as_relationship()
assert isinstance(relationship, Relationship)
def test_as_bool(self):
value = ttypes.Value()
value.set_bVal(False)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_bool()
node = value_wrapper.as_bool()
assert isinstance(node, bool)
def test_as_path(self):
value = ttypes.Value()
value.set_pVal(self.get_path_value(b'Tom'))
vaue_wrapper = ValueWrapper(value)
assert vaue_wrapper.is_path()
node = vaue_wrapper.as_path()
assert isinstance(node, PathWrapper)
def test_as_geography(self):
value = ttypes.Value()
value.set_ggVal(self.get_geography_value(3.0, 5.2))
vaue_wrapper = ValueWrapper(value)
assert vaue_wrapper.is_geography()
geog = vaue_wrapper.as_geography()
assert isinstance(geog, GeographyWrapper)
def test_as_double(self):
value = ttypes.Value()
value.set_fVal(10.10)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_double()
node = value_wrapper.as_double()
assert isinstance(node, float)
def test_as_string(self):
value = ttypes.Value()
value.set_sVal(b'Tom')
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_string()
str_val = value_wrapper.as_string()
assert isinstance(str_val, str)
def test_as_list(self):
value = ttypes.Value()
str_val1 = ttypes.Value()
str_val1.set_sVal(b"word")
str_val2 = ttypes.Value()
str_val2.set_sVal(b"car")
value.set_lVal([str_val1, str_val2])
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_list()
list_val = value_wrapper.as_list()
assert isinstance(list_val, list)
def test_as_map(self):
value = ttypes.Value()
str_val1 = ttypes.Value()
str_val1.set_sVal(b"word")
str_val2 = ttypes.Value()
str_val2.set_sVal(b"car")
value.set_mVal({b"a": str_val1, b"b": str_val2})
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_map()
map_val = value_wrapper.as_map()
assert isinstance(map_val, dict)
def test_as_date(self):
date = Date()
date.year = 220
date.month = 2
date.day = 10
value = ttypes.Value(dVal=date)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_date()
date_val = value_wrapper.as_date()
assert isinstance(date_val, DateWrapper)
assert date_val.get_year() == 220
assert date_val.get_month() == 2
assert date_val.get_day() == 10
assert '220-02-10' == str(date_val)
def get_dst_id(self):
if len(self._row.values) < 4:
raise RuntimeError('The row value is bad format, '
'get edge dst id failed: len is {}'.format(
len(self._row.values)))
assert self._row.values[3].getType() == ttypes.Value.SVAL
return ValueWrapper(self._row.values[3], self._decode_type)
def test_as_set(self):
value = ttypes.Value()
str_val1 = ttypes.Value()
str_val1.set_sVal(b"word")
str_val2 = ttypes.Value()
str_val2.set_uVal(b"car")
set_val = Set()
set_val.values = set()
set_val.values.add(str_val1)
set_val.values.add(str_val2)
value.set_uVal(set_val)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_set()
set_val = value_wrapper.as_set()
assert isinstance(set_val, set)
def test_as_time(self):
time = Time()
time.hour = 10
time.minute = 20
time.sec = 10
time.microsec = 100
value = ttypes.Value(tVal=time)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_time()
time_val = value_wrapper.as_time()
assert isinstance(time_val, TimeWrapper)
assert time_val.get_hour() == 10
assert time_val.get_minute() == 20
assert time_val.get_sec() == 10
assert time_val.get_microsec() == 100
assert '10:20:10.000100' == str(time_val)
def get_prop_values(self):
"""get all prop values from the edge data
:return: list<ValueWrapper>
"""
index = self.PROP_START_INDEX
prop_values = []
while index < len(self._row.values):
prop_values.append(ValueWrapper(self._row.values[index], decode_type=self._decode_type))
index = index + 1
return prop_values
def get_id(self):
"""get vertex id, if the space vid_type is int, you can use get_id().as_int(),
if the space vid_type is fixed_string, you can use get_id().as_string()
:return: ValueWrapper
"""
if len(self._row.values) < 1:
raise RuntimeError('The row value is bad format, '
'get vertex id failed: len is {}'
.format(len(self._row.values)))
return ValueWrapper(self._row.values[0], self._decode_type)
def test_as_datetime(self):
datetime = DateTime()
datetime.year = 123
datetime.month = 2
datetime.day = 1
datetime.hour = 10
datetime.minute = 20
datetime.sec = 10
datetime.microsec = 100
value = ttypes.Value(dtVal=datetime)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_datetime()
datetime_val = value_wrapper.as_datetime()
assert isinstance(datetime_val, DateTimeWrapper)
assert datetime_val.get_hour() == 10
assert datetime_val.get_minute() == 20
assert datetime_val.get_sec() == 10
assert datetime_val.get_microsec() == 100
assert '123-02-01T10:20:10.000100' == str(datetime_val)
def test_as_relationship(self):
value = ttypes.Value(eVal=self.get_edge_value(b'Tom', b'Lily'))
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_edge()
relationship = value_wrapper.as_relationship()
assert isinstance(relationship, Relationship)
# test with reversely
reversely_value = ttypes.Value(eVal=self.get_edge_value(b'Lily', b'Tom', True))
reversely_value_wrapper = ValueWrapper(reversely_value)
reversely_relationship = reversely_value_wrapper.as_relationship()
assert isinstance(reversely_relationship, Relationship)
assert reversely_relationship == relationship
# test with reversely no equal
reversely_value = ttypes.Value(eVal=self.get_edge_value(b'Tom', b'Lily', True))
reversely_value_wrapper = ValueWrapper(reversely_value)
reversely_relationship = reversely_value_wrapper.as_relationship()
assert isinstance(reversely_relationship, Relationship)
assert reversely_relationship != relationship
def test_as_node(self):
value = ttypes.Value()
value.set_vVal(self.get_vertex_value(b'Tom'))
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_vertex()
node = value_wrapper.as_node()
assert isinstance(node, Node)
assert node.get_id().as_string() == 'Tom'
assert node.has_tag('tag1')
assert node.prop_names('tag1').sort() == [
'prop0', 'prop1', 'prop2', 'prop3', 'prop4'
].sort()
expect_values = [(v.as_int()) for v in node.prop_values('tag1')]
assert expect_values == [0, 1, 2, 3, 4]
assert node.tags() == ['tag0', 'tag1', 'tag2']
assert list(node.properties('tag1').keys()).sort() == [
'prop0', 'prop1', 'prop2', 'prop3', 'prop4'
].sort()
expect_values = [(v.as_int())
for v in node.properties('tag1').values()]
assert expect_values == [0, 1, 2, 3, 4]
def executing_query_with_params(query, indices, keys, graph_spaces, session, request):
indices_list = [int(v) for v in indices.split(",")]
key_list = [request.node.name + key for key in keys.split(",")]
assert len(indices_list) == len(
key_list
), f"Length not match for keys and indices: {keys} <=> {indices}"
vals = []
register_lock.acquire()
for (key, index) in zip(key_list, indices_list):
vals.append(ValueWrapper(register_dict[key][index]))
register_lock.release()
ngql = combine_query(query).format(*vals)
exec_query(request, ngql, session, graph_spaces)
def test_as_list(self):
value = ttypes.Value()
str_val1 = ttypes.Value()
str_val1.set_sVal(b"word")
str_val2 = ttypes.Value()
str_val2.set_sVal(b"car")
val_list = NList()
val_list.values = [str_val1, str_val2]
value.set_lVal(val_list)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_list()
list_val = value_wrapper.as_list()
assert isinstance(list_val, list)
expect_result = [ValueWrapper(ttypes.Value(sVal=b"word")),
ValueWrapper(ttypes.Value(sVal=b"car"))]
assert list_val == expect_result
def test_as_map(self):
value = ttypes.Value()
str_val1 = ttypes.Value()
str_val1.set_sVal(b"word")
str_val2 = ttypes.Value()
str_val2.set_sVal(b"car")
map_val = NMap()
map_val.kvs = {b"a": str_val1, b"b": str_val2}
value.set_mVal(map_val)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_map()
map_val = value_wrapper.as_map()
assert isinstance(map_val, dict)
expect_result = dict()
expect_result["a"] = ValueWrapper(ttypes.Value(sVal=b"word"))
expect_result["b"] = ValueWrapper(ttypes.Value(sVal=b"car"))
assert map_val == expect_result
def test_as_set(self):
value = ttypes.Value()
str_val1 = ttypes.Value()
str_val1.set_sVal(b"word")
str_val2 = ttypes.Value()
str_val2.set_sVal(b"car")
set_val = NSet()
set_val.values = set()
set_val.values.add(str_val1)
set_val.values.add(str_val2)
value.set_uVal(set_val)
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_set()
set_val = value_wrapper.as_set()
assert isinstance(set_val, set)
expect_result = set()
expect_result.add(ValueWrapper(ttypes.Value(sVal=b"word")))
expect_result.add(ValueWrapper(ttypes.Value(sVal=b"car")))
assert set_val == expect_result
def test_as_relationship(self):
value = ttypes.Value(eVal=self.get_edge_value(b'Tom', b'Lily'))
value_wrapper = ValueWrapper(value)
assert value_wrapper.is_edge()
relationship = value_wrapper.as_relationship()
assert isinstance(relationship, Relationship)
# test with reversely
reversely_value = ttypes.Value(
eVal=self.get_edge_value(b'Lily', b'Tom', True))
reversely_value_wrapper = ValueWrapper(reversely_value)
reversely_relationship = reversely_value_wrapper.as_relationship()
assert isinstance(reversely_relationship, Relationship)
assert reversely_relationship == relationship
# test with reversely no equal
reversely_value = ttypes.Value(
eVal=self.get_edge_value(b'Tom', b'Lily', True))
reversely_value_wrapper = ValueWrapper(reversely_value)
reversely_relationship = reversely_value_wrapper.as_relationship()
assert isinstance(reversely_relationship, Relationship)
assert reversely_relationship != relationship
relationship.ranking() == 100
relationship.edge_name() == 'classmate'
relationship.start_vertex_id().as_string() == 'Lily'
relationship.start_vertex_id().as_string() == 'Tom'
assert relationship.keys() == [
'prop0', 'prop1', 'prop2', 'prop3', 'prop4'
]
expect_values = [(v.as_int()) for v in relationship.values()]
assert expect_values == [0, 1, 2, 3, 4]
assert list(relationship.properties().keys()).sort() == [
'prop0', 'prop1', 'prop2', 'prop3', 'prop4'
].sort()
expect_values = [(v.as_int())
for v in relationship.properties().values()]
assert expect_values == [0, 1, 2, 3, 4]
# test empty props
value = ttypes.Value(
eVal=self.get_edge_value(b'Tom', b'Lily', empty_props=True))
relationship = ValueWrapper(value).as_relationship()
assert relationship.keys() == []
assert relationship.values() == []
assert len(relationship.properties()) == 0
def get_id(self):
if len(self._row.values) < 1:
raise RuntimeError('The row value is bad format, '
'get vertex id failed: len is {}'.format(
len(self._row.values)))
return ValueWrapper(self._row.values[0], self._decode_type)
def test_all_interface(self):
result = self.get_result_set()
assert result.space_name() == "test"
assert result.comment() == "Permission"
assert result.error_msg() == "Permission"
assert result.error_code() == ErrorCode.E_BAD_PERMISSION
assert result.plan_desc() is None
assert result.latency() == 100
assert not result.is_empty()
assert not result.is_succeeded()
expect_keys = [
"col1_empty", "col2_null", "col3_bool", "col4_int", "col5_double",
"col6_string", "col7_list", "col8_set", "col9_map", "col10_time",
"col11_date", "col12_datetime", "col13_vertex", "col14_edge",
"col15_path"
]
assert result.keys() == expect_keys
assert result.col_size() == 15
assert result.row_size() == 2
# test column_values
assert len(result.column_values("col6_string")) == 2
assert result.column_values("col6_string")[0].is_string()
assert result.column_values(
"col6_string")[0].as_string() == "hello world"
# test row_values
assert len(result.row_values(0)) == 15
assert result.row_values(0)[5].is_string()
assert result.row_values(0)[5].as_string() == "hello world"
# test rows
assert len(result.rows()) == 2
assert len(result.rows()[0].values) == 15
assert isinstance(result.rows()[0].values[0], Value)
assert isinstance(result.get_row_types(), list)
# test get_row_types
assert result.get_row_types() == [
ttypes.Value.__EMPTY__, ttypes.Value.NVAL, ttypes.Value.BVAL,
ttypes.Value.IVAL, ttypes.Value.FVAL, ttypes.Value.SVAL,
ttypes.Value.LVAL, ttypes.Value.UVAL, ttypes.Value.MVAL,
ttypes.Value.TVAL, ttypes.Value.DVAL, ttypes.Value.DTVAL,
ttypes.Value.VVAL, ttypes.Value.EVAL, ttypes.Value.PVAL
]
# test record
in_use = False
for record in result:
in_use = True
record.size() == 15
# test keys()
assert record.keys() == expect_keys
# test values()
values = record.values()
assert len(record.values()) == 15
assert record.values()[0].is_empty()
assert record.values()[5].is_string()
assert record.values()[5].is_string()
assert record.values()[5].as_string() == "hello world"
# test get_value()
assert record.get_value(0).is_empty()
assert values[0].is_empty()
assert record.get_value(1).is_null()
assert record.get_value(1).as_null() == Null(Null.BAD_DATA)
null_value = Value(nVal=Null.BAD_DATA)
assert record.get_value(1) == ValueWrapper(null_value)
assert str(record.get_value(1).as_null()) == 'BAD_DATA'
# test get_value_by_key()
assert record.get_value_by_key('col2_null').is_null()
assert record.get_value_by_key('col3_bool').is_bool()
assert not record.get_value_by_key('col3_bool').as_bool()
# get_value_by_key with not exited key
try:
record.get_value_by_key('not existed')
assert False, 'Not expect here'
except InvalidKeyException as e:
assert True
assert e.message == "KeyError: `not existed'"
assert values[1].is_null()
assert record.get_value(2).is_bool()
assert not record.get_value(2).as_bool()
assert record.get_value(2).is_bool()
assert record.get_value(3).is_int()
assert record.get_value(3).as_int() == 100
assert record.get_value(4).is_double()
assert record.get_value(4).as_double() == 10.01
assert record.get_value(5).is_string()
assert record.get_value(5).as_string() == "hello world"
assert record.get_value(6).is_list()
assert record.get_value(7).is_set()
assert record.get_value(8).is_map()
assert record.get_value(9).is_time()
assert record.get_value(10).is_date()
assert record.get_value(11).is_datetime()
assert record.get_value(12).is_vertex()
assert record.get_value(13).is_edge()
assert record.get_value(14).is_path()
assert in_use
# test use iterator again
in_use = False
for record in result:
in_use = True
record.size() == 15
assert in_use
def compare_value(self, lhs: ValueWrapper, rhs: ValueWrapper):
"""
lhs and rhs represent response data and expected data respectively
"""
if lhs.is_null():
return rhs.is_null() and lhs.as_null() == rhs.as_null()
if lhs.is_empty():
return rhs.is_empty()
if lhs.is_bool():
return rhs.is_bool() and lhs.as_bool() == rhs.as_bool()
if lhs.is_int():
return rhs.is_int() and lhs.as_int() == rhs.as_int()
if lhs.is_double():
return (rhs.is_double()
and math.fabs(lhs.as_double() - rhs.as_double()) < 1.0E-8)
if lhs.is_string():
return rhs.is_string() and lhs.as_string() == rhs.as_string()
if lhs.is_date():
return (rhs.is_date() and lhs.as_date() == rhs.as_date()) or (
rhs.is_string() and str(lhs.as_date()) == rhs.as_string())
if lhs.is_time():
return (rhs.is_time() and lhs.as_time() == rhs.as_time()) or (
rhs.is_string() and str(lhs.as_time()) == rhs.as_string())
if lhs.is_datetime():
return ((rhs.is_datetime()
and lhs.as_datetime() == rhs.as_datetime())
or (rhs.is_string()
and str(lhs.as_datetime()) == rhs.as_string()))
if lhs.is_list():
return rhs.is_list() and self.compare_list(lhs.as_list(),
rhs.as_list())
if lhs.is_set():
return rhs.is_set() and self._compare_list(
lhs.as_set(), rhs.as_set(), self.compare_value)
if lhs.is_map():
return rhs.is_map() and self.compare_map(lhs.as_map(),
rhs.as_map())
if lhs.is_vertex():
return rhs.is_vertex() and self.compare_node(
lhs.as_node(), rhs.as_node())
if lhs.is_edge():
return rhs.is_edge() and self.compare_edge(lhs.as_relationship(),
rhs.as_relationship())
if lhs.is_path():
return rhs.is_path() and self.compare_path(lhs.as_path(),
rhs.as_path())
return False
