def test_evict():
env = Env()
env.skipOnCluster()
skip_on_rlec()
with env.getClusterConnectionIfNeeded() as r:
info = r.execute_command('INFO')
max_mem = info['used_memory'] + 1024 * 1024
assert r.execute_command('CONFIG', 'SET', 'maxmemory',
str(max_mem) + 'b')
assert r.execute_command('CONFIG', 'SET', 'maxmemory-policy',
'allkeys-lru')
init(env, r)
# make sure t{1} deleted
res = r.execute_command('keys *')
i = 4
while b't{1}' in res:
assert r.execute_command('TS.CREATE', 't{%s}' % (i, ))
i += 1
res = r.execute_command('keys *')
res = r.execute_command('TS.QUERYINDEX', 'name=(mush)')
env.assertEqual(res, [])
# restore maxmemory
assert r.execute_command('CONFIG', 'SET', 'maxmemory', '0')
def test_rename_dst():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.CREATE', 'a{2}')
assert r.execute_command('TS.CREATE', 'b{2}')
assert r.execute_command('TS.CREATERULE', 'a{2}', 'b{2}',
'AGGREGATION', 'AVG', 5000)
env.assertTrue(r.execute_command('RENAME', 'b{2}', 'b1{2}'))
aInfo = TSInfo(r.execute_command('TS.INFO', 'a{2}'))
env.assertEqual(aInfo.sourceKey, None)
env.assertEqual(aInfo.rules[0][0], b'b1{2}')
assert r.execute_command('TS.CREATE', 'c{2}')
assert r.execute_command('TS.CREATERULE', 'a{2}', 'c{2}',
'AGGREGATION', 'COUNT', 2000)
assert r.execute_command('TS.CREATE', 'd{2}')
assert r.execute_command('TS.CREATERULE', 'a{2}', 'd{2}',
'AGGREGATION', 'SUM', 3000)
env.assertTrue(r.execute_command('RENAME', 'c{2}', 'c1{2}'))
aInfo = TSInfo(r.execute_command('TS.INFO', 'a{2}'))
env.assertEqual(aInfo.sourceKey, None)
env.assertEqual(aInfo.rules[0][0], b'b1{2}')
env.assertEqual(aInfo.rules[1][0], b'c1{2}')
env.assertEqual(aInfo.rules[2][0], b'd{2}')
def test_groupby_reduce_empty():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.ADD', 's1', 1, 100, 'LABELS', 'metric_family', 'cpu', 'metric_name', 'user')
assert r.execute_command('TS.ADD', 's2', 2, 55, 'LABELS', 'metric_family', 'cpu', 'metric_name', 'user')
assert r.execute_command('TS.ADD', 's3', 2, 40, 'LABELS', 'metric_family', 'cpu', 'metric_name', 'system')
assert r.execute_command('TS.ADD', 's1', 2, 95)
actual_result = r.execute_command(
'TS.mrange', '-', '+', 'WITHLABELS', 'FILTER', 'metric_family=cpu', 'GROUPBY', 'labelX', 'REDUCE', 'max')
env.assertEqual(actual_result, [])
def test_rename_indexed():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.ADD', 'a{3}', 100, 200, 'LABELS', 'sensor_id', '2', 'area_id', '32')
env.assertEqual(r.execute_command('TS.MGET', 'FILTER', 'area_id=32'), [[b'a{3}', [], [100, b'200']]])
env.assertTrue(r.execute_command('RENAME', 'a{3}', 'a1{3}'))
env.assertEqual(r.execute_command('TS.MGET', 'FILTER', 'area_id=32'), [[b'a1{3}', [], [100, b'200']]])
def test_unlink():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
init(env, r)
res = r.execute_command('UNLINK', 't{1}')
res = r.execute_command('TS.QUERYINDEX', 'name=(mush,zavi,rex)')
env.assertEqual(sorted(res), sorted([b't{2}', b't{1}_agg']))
res = r.execute_command('TS.MGET', 'filter', 'name=(mush,zavi,rex)')
env.assertEqual(sorted(res),
sorted([[b't{2}', [], []], [b't{1}_agg', [], []]]))
def test_flush():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
init(env, r)
assert r.execute_command('FLUSHALL')
res = r.execute_command('TS.QUERYINDEX', 'name=(mush,zavi,rex)')
env.assertEqual(res, [])
init(env, r)
assert r.execute_command('FLUSHDB')
res = r.execute_command('TS.QUERYINDEX', 'name=(mush,zavi,rex)')
env.assertEqual(res, [])
def test_rename_none_ts():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.CREATE', 'a{4}')
assert r.execute_command('SET', 'key1{4}', 'val1')
assert r.execute_command('SET', 'key2{4}', 'val2')
env.assertTrue(r.execute_command('RENAME', 'key1{4}', 'key3{4}'))
env.assertTrue(r.execute_command('RENAME', 'key2{4}', 'key1{4}'))
assert r.execute_command('SET', 'key1{4}', 'val3')
assert r.execute_command('SET', 'key3{4}', 'val4')
aInfo = TSInfo(r.execute_command('TS.INFO', 'a{4}'))
env.assertEqual(aInfo.sourceKey, None)
env.assertEqual(aInfo.rules, [])
def test_non_local_data():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
r.execute_command('TS.ADD', '{host1}_metric_1', 1, 100, 'LABELS',
'metric', 'cpu')
r.execute_command('TS.ADD', '{host1}_metric_2', 2, 40, 'LABELS',
'metric', 'cpu')
r.execute_command('TS.ADD', '{host1}_metric_1', 2, 95)
r.execute_command('TS.ADD', '{host1}_metric_1', 10, 99)
previous_results = []
# ensure that initiating the query on different shards always replies with the same series
for shard in range(0, env.shardsCount):
shard_conn = env.getConnection(shard)
actual_result = shard_conn.execute_command(
'TS.MRANGE - + FILTER metric=cpu')
env.assertEqual(len(actual_result), 2)
for previous_result in previous_results:
ensure_replies_series_match(env, previous_result, actual_result)
previous_results.append(actual_result)
def test_non_local_filtered_data():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
r.execute_command('TS.ADD', '{host1}_metric_1', 1, 100, 'LABELS',
'metric', 'cpu')
r.execute_command('TS.ADD', '{host1}_metric_2', 2, 40, 'LABELS',
'metric', 'cpu')
r.execute_command('TS.ADD', '{host1}_metric_1', 2, 95)
r.execute_command('TS.ADD', '{host1}_metric_1', 10, 99)
previous_results = []
# ensure that initiating the query on different shards always replies with the same series
for shard in range(0, env.shardsCount):
shard_conn = env.getConnection(shard)
# send undordered timestamps to test for sorting
actual_result = shard_conn.execute_command(
'TS.MRANGE - + FILTER_BY_TS 11 5 25 55 101 18 9 1900 2 FILTER metric=cpu'
)
env.assertEqual(len(actual_result), 2)
# ensure reply is properly filtered by TS
for serie in actual_result:
serie_ts = serie[2]
# ensure only timestamp 2 is present on reply
env.assertEqual(len(serie_ts), 1)
env.assertEqual(serie_ts[0][0], 2)
for previous_result in previous_results:
ensure_replies_series_match(env, previous_result, actual_result)
previous_results.append(actual_result)
def testLibmrFail():
env = Env()
if env.shardsCount < 3:
env.skip()
if (not env.isCluster):
env.skip()
env.skipOnSlave() # There can't be 2 rdb save at the same time
env.skipOnAOF()
start_ts = 1
samples_count = 10
with env.getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.CREATE', 'tester1{1}', 'LABELS', 'name',
'bob')
_insert_data(r, 'tester1{1}', start_ts, samples_count, 1)
try:
env.envRunner.shards[2].stopEnv()
except Exception as e:
pass
Refresh_Cluster(env)
try:
actual_result = env.getConnection(1).execute_command(
'TS.mrange', start_ts, start_ts + samples_count, 'WITHLABELS',
'FILTER', 'name=bob')
assert (False)
except Exception as e:
env.assertResponseError(e, "multi shard cmd failed")
env.envRunner.shards[2].startEnv()
Refresh_Cluster(env)
expected_res = [[
b'tester1{1}', [[b'name', b'bob']],
[[1, b'1'], [2, b'1'], [3, b'1'], [4, b'1'], [5, b'1'], [6, b'1'],
[7, b'1'], [8, b'1'], [9, b'1'], [10, b'1']]
]]
actual_result = env.getConnection(1).execute_command(
'TS.mrange', start_ts, start_ts + samples_count, 'WITHLABELS',
'FILTER', 'name=bob')
env.assertEqual(actual_result, expected_res)
def test_restore():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
init(env, r)
serialized_val = r.execute_command('DUMP', 't{1}')
assert r.execute_command('del', 't{1}')
res = r.execute_command('TS.QUERYINDEX', 'name=(mush,zavi,rex)')
env.assertEqual(sorted(res), sorted({b't{2}', b't{1}_agg'}))
res = r.execute_command('TS.MGET', 'filter', 'name=(mush,zavi,rex)')
env.assertEqual(sorted(res),
sorted([[b't{1}_agg', [], []], [b't{2}', [], []]]))
assert r.execute_command('RESTORE', 't{1}', '0', serialized_val)
res = r.execute_command('TS.QUERYINDEX', 'name=(mush,zavi,rex)')
env.assertEqual(sorted(res), sorted([b't{1}', b't{2}', b't{1}_agg']))
res = r.execute_command('TS.MGET', 'filter', 'name=(mush,zavi,rex)')
env.assertEqual(
sorted(res),
sorted([[b't{1}', [], [10, b'19']], [b't{2}', [], []],
[b't{1}_agg', [], []]]))
def test_renamenx():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
init(env, r)
assert r.execute_command('RENAMENX', 't{1}', 't{1}_renamed')
res = r.execute_command('ts.info', 't{1}_agg')
index = res.index(b'sourceKey')
env.assertEqual(res[index + 1], b't{1}_renamed')
res = r.execute_command('TS.QUERYINDEX', 'name=(mush,zavi,rex)')
env.assertEqual(sorted(res), [b't{1}_agg', b't{1}_renamed', b't{2}'])
res = r.execute_command('TS.MGET', 'filter', 'name=(mush,zavi,rex)')
env.assertEqual(
sorted(res),
[[b't{1}_agg', [], []], [b't{1}_renamed', [], [10, b'19']],
[b't{2}', [], []]])
assert r.execute_command('RENAMENX', 't{1}_agg', 't{1}_agg_renamed')
res = r.execute_command('ts.info', 't{1}_renamed')
index = res.index(b'rules')
env.assertEqual(res[index + 1], [[b't{1}_agg_renamed', 10, b'AVG']])
def test_mrange_filterby():
start_ts = 1511885909
samples_count = 50
env = Env()
with env.getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.CREATE', 'tester1', 'LABELS', 'name',
'bob', 'class', 'middle', 'generation', 'x')
assert r.execute_command('TS.CREATE', 'tester2', 'LABELS', 'name',
'rudy', 'class', 'junior', 'generation', 'x')
assert r.execute_command('TS.CREATE', 'tester3', 'LABELS', 'name',
'fabi', 'class', 'top', 'generation', 'x')
_insert_data(r, 'tester1', start_ts, samples_count, 5)
_insert_data(r, 'tester2', start_ts, samples_count, 15)
_insert_data(r, 'tester3', start_ts, samples_count, 25)
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'FILTER_BY_VALUE', "a", 1, 'FILTER',
'name=bob')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'FILTER_BY_VALUE', "a", "a", 'FILTER',
'name=bob')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'FILTER_BY_VALUE', 1, "a", 'FILTER',
'name=bob')
expected_result = [
[b'tester1', [], []],
[
b'tester2', [],
[[start_ts + i, str(15).encode('ascii')]
for i in range(samples_count)]
],
[b'tester3', [], []],
]
actual_result = r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'FILTER_BY_VALUE', 10, 20, 'FILTER',
'generation=x')
env.assertEqual(sorted(actual_result), sorted(expected_result))
expected_result = [
[b'tester1', [], []],
[
b'tester2', [],
[[start_ts + i, str(15).encode('ascii')] for i in range(9, 12)]
],
[b'tester3', [], []],
]
actual_result = r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'FILTER_BY_TS', start_ts + 9,
start_ts + 10, start_ts + 11,
'FILTER_BY_VALUE', 10, 20, 'FILTER',
'generation=x')
env.assertEqual(sorted(actual_result), sorted(expected_result))
def test_groupby_reduce_multiple_groups():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.ADD', 's1', 1, 100, 'LABELS', 'HOST', 'A', 'REGION', 'EU', 'PROVIDER', 'AWS')
assert r.execute_command('TS.ADD', 's2', 1, 55, 'LABELS', 'HOST', 'B', 'REGION', 'EU', 'PROVIDER', 'AWS')
assert r.execute_command('TS.ADD', 's2', 2, 90, 'LABELS', 'HOST', 'B', 'REGION', 'EU', 'PROVIDER', 'AWS')
assert r.execute_command('TS.ADD', 's3', 2, 40, 'LABELS', 'HOST', 'C', 'REGION', 'US', 'PROVIDER', 'AWS')
actual_result = r.execute_command(
'TS.mrange', '-', '+', 'WITHLABELS', 'FILTER', 'PROVIDER=AWS', 'GROUPBY', 'REGION', 'REDUCE', 'max')
serie1 = actual_result[0]
serie1_name = serie1[0]
serie1_labels = serie1[1]
serie1_values = serie1[2]
env.assertEqual(serie1_values, [[1, b'100'],[2, b'90']])
env.assertEqual(serie1_name, b'REGION=EU')
env.assertEqual(serie1_labels[0][0], b'REGION')
env.assertEqual(serie1_labels[0][1], b'EU')
env.assertEqual(serie1_labels[1][0], b'__reducer__')
env.assertEqual(serie1_labels[1][1], b'max')
env.assertEqual(serie1_labels[2][0], b'__source__')
env.assertEqual(sorted(serie1_labels[2][1].decode("ascii").split(",")), ['s1', 's2'])
serie2 = actual_result[1]
serie2_name = serie2[0]
serie2_labels = serie2[1]
serie2_values = serie2[2]
env.assertEqual(serie2_values, [[2, b'40']])
env.assertEqual(serie2_name, b'REGION=US')
env.assertEqual(serie2_labels[0][0], b'REGION')
env.assertEqual(serie2_labels[0][1], b'US')
env.assertEqual(serie2_labels[1][0], b'__reducer__')
env.assertEqual(serie2_labels[1][1], b'max')
env.assertEqual(serie2_labels[2][0], b'__source__')
env.assertEqual(serie2_labels[2][1], b's3')
def test_groupby_reduce():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.ADD', 's1', 1, 100, 'LABELS', 'metric_family', 'cpu', 'metric_name', 'user')
assert r.execute_command('TS.ADD', 's2', 2, 55, 'LABELS', 'metric_family', 'cpu', 'metric_name', 'user')
assert r.execute_command('TS.ADD', 's3', 2, 40, 'LABELS', 'metric_family', 'cpu', 'metric_name', 'system')
assert r.execute_command('TS.ADD', 's1', 2, 95)
actual_result = r.execute_command(
'TS.mrange', '-', '+', 'WITHLABELS', 'FILTER', 'metric_family=cpu', 'GROUPBY', 'metric_name', 'REDUCE', 'max')
serie1 = actual_result[0]
serie1_name = serie1[0]
serie1_labels = serie1[1]
serie1_values = serie1[2]
env.assertEqual(serie1_values, [[2, b'40']])
env.assertEqual(serie1_name, b'metric_name=system')
env.assertEqual(serie1_labels[0][0], b'metric_name')
env.assertEqual(serie1_labels[0][1], b'system')
serie2 = actual_result[1]
serie2_name = serie2[0]
serie2_labels = serie2[1]
serie2_values = serie2[2]
env.assertEqual(serie2_name, b'metric_name=user')
env.assertEqual(serie2_labels[0][0], b'metric_name')
env.assertEqual(serie2_labels[0][1], b'user')
env.assertEqual(serie2_labels[1][0], b'__reducer__')
env.assertEqual(serie2_labels[1][1], b'max')
env.assertEqual(serie2_labels[2][0], b'__source__')
env.assertEqual(sorted(serie2_labels[2][1].decode("ascii").split(",")), ['s1', 's2'])
env.assertEqual(serie2_values, [[1, b'100'], [2, b'95']])
actual_result = r.execute_command(
'TS.mrange', '-', '+', 'WITHLABELS', 'FILTER', 'metric_family=cpu', 'GROUPBY', 'metric_name', 'REDUCE', 'sum')
serie2 = actual_result[1]
serie2_values = serie2[2]
env.assertEqual(serie2_values, [[1, b'100'], [2, b'150']])
actual_result = r.execute_command(
'TS.mrange', '-', '+', 'WITHLABELS', 'FILTER', 'metric_family=cpu', 'GROUPBY', 'metric_name', 'REDUCE', 'min')
serie2 = actual_result[1]
serie2_values = serie2[2]
env.assertEqual(serie2_values, [[1, b'100'], [2, b'55']])
actual_result = r.execute_command(
'TS.mrange', '-', '+', 'WITHLABELS', 'COUNT', 1, 'FILTER', 'metric_family=cpu', 'GROUPBY', 'metric_name', 'REDUCE', 'min')
serie2 = actual_result[1]
serie2_values = serie2[2]
env.assertEqual(serie2_values, [[1, b'100']])
def test_copy_compressed_uncompressed():
env = Env()
env.skipOnVersionSmaller("6.2.0")
for compresssion in ["UNCOMPRESSED", 'COMPRESSED']:
with env.getClusterConnectionIfNeeded() as r:
r.execute_command('FLUSHALL')
init(env, r, compression=compresssion)
for i in range(1000):
assert r.execute_command('TS.ADD', 't{1}', 1638304650 + i, i)
assert r.execute_command('COPY', 't{1}', 't{1}_copied')
t1_info = r.execute_command('ts.info', 't{1}')
res = r.execute_command('ts.info', 't{1}_agg')
index = res.index(b'sourceKey')
env.assertEqual(res[index + 1], b't{1}')
res = r.execute_command('ts.info', 't{1}_copied')
index = res.index(b'sourceKey')
env.assertEqual(res[index + 1], None)
index = res.index(b'rules')
env.assertEqual(res[index + 1], [])
index = res.index(b'labels')
env.assertEqual(res[index + 1], t1_info[index + 1])
data = r.execute_command('TS.range', 't{1}', '-', '+')
copied_data = r.execute_command(
'TS.range',
't{1}_copied',
'-',
'+',
)
assert data == copied_data
res = r.execute_command('TS.QUERYINDEX', 'name=(mush,zavi,rex)')
env.assertEqual(
sorted(res),
sorted([b't{1}', b't{2}', b't{1}_agg', b't{1}_copied']))
res = r.execute_command('TS.MGET', 'filter',
'name=(mush,zavi,rex)')
env.assertEqual(
sorted(res),
sorted([[b't{1}', [], [1638305649, b'999']], [b't{2}', [], []],
[b't{1}_agg', [], [1638305630, b'984.5']],
[b't{1}_copied', [], [1638305649, b'999']]]))
assert r.execute_command('COPY', 't{1}_agg', 't{1}_agg_copied')
res = r.execute_command('ts.info', 't{1}_agg_copied')
index = res.index(b'sourceKey')
env.assertEqual(res[index + 1], None)
index = res.index(b'rules')
env.assertEqual(res[index + 1], [])
res = r.execute_command('TS.QUERYINDEX', 'name=(mush,zavi,rex)')
env.assertEqual(
sorted(res),
sorted([
b't{1}', b't{2}', b't{1}_agg', b't{1}_copied',
b't{1}_agg_copied'
]))
res = r.execute_command('TS.MGET', 'filter',
'name=(mush,zavi,rex)')
env.assertEqual(
sorted(res),
sorted([[b't{1}', [], [1638305649, b'999']], [b't{2}', [], []],
[b't{1}_agg', [], [1638305630, b'984.5']],
[b't{1}_copied', [], [1638305649, b'999']],
[b't{1}_agg_copied', [], [1638305630, b'984.5']]]))
def test_range_by_labels():
start_ts = 1511885909
samples_count = 50
env = Env()
with Env().getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.CREATE', 'tester1', 'LABELS', 'name',
'bob', 'class', 'middle', 'generation', 'x')
assert r.execute_command('TS.CREATE', 'tester2', 'LABELS', 'name',
'rudy', 'class', 'junior', 'generation', 'x')
assert r.execute_command('TS.CREATE', 'tester3', 'LABELS', 'name',
'fabi', 'class', 'top', 'generation', 'x')
_insert_data(r, 'tester1', start_ts, samples_count, 5)
_insert_data(r, 'tester2', start_ts, samples_count, 15)
_insert_data(r, 'tester3', start_ts, samples_count, 25)
expected_result = [[start_ts + i, str(5).encode('ascii')]
for i in range(samples_count)]
actual_result = r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'FILTER',
'name=bob')
assert [[b'tester1', [], expected_result]] == actual_result
expected_result.reverse()
actual_result = r.execute_command('TS.mrevrange', start_ts,
start_ts + samples_count, 'FILTER',
'name=bob')
assert [[b'tester1', [], expected_result]] == actual_result
def build_expected(val, time_bucket):
return [[int(i - i % time_bucket),
str(val).encode('ascii')]
for i in range(start_ts, start_ts + samples_count +
1, time_bucket)]
actual_result = r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'AGGREGATION', 'LAST', 5, 'FILTER',
'generation=x')
expected_result = [
[b'tester1', [], build_expected(5, 5)],
[b'tester2', [], build_expected(15, 5)],
[b'tester3', [], build_expected(25, 5)],
]
env.assertEqual(sorted(expected_result), sorted(actual_result))
assert expected_result[1:] == sorted(r.execute_command(
'TS.mrange', start_ts, start_ts + samples_count, 'AGGREGATION',
'LAST', 5, 'FILTER', 'generation=x', 'class!=middle'),
key=lambda x: x[0])
actual_result = r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'COUNT', 3,
'AGGREGATION', 'LAST', 5, 'FILTER',
'generation=x')
assert expected_result[0][2][:3] == sorted(actual_result,
key=lambda x: x[0])[0][2]
actual_result = r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'AGGREGATION', 'COUNT', 5, 'FILTER',
'generation=x')
assert [[1511885905, b'1']] == actual_result[0][2][:1]
assert expected_result[0][2][1:9] == actual_result[0][2][1:9]
actual_result = r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'AGGREGATION', 'COUNT', 3, 'COUNT',
3, 'FILTER', 'generation=x')
assert 3 == len(actual_result[0]
[2]) # just checking that agg count before count works
actual_result = r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'COUNT', 3,
'AGGREGATION', 'COUNT', 3, 'FILTER',
'generation=x')
assert 3 == len(actual_result[0]
[2]) # just checking that agg count before count works
actual_result = r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'AGGREGATION', 'COUNT', 3, 'FILTER',
'generation=x')
assert 18 == len(
actual_result[0]
[2]) # just checking that agg count before count works
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'AGGREGATION',
'invalid', 3, 'FILTER', 'generation=x')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'AGGREGATION',
'AVG', 'string', 'FILTER', 'generation=x')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'COUNT',
'string', 'FILTER', 'generation=x')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', '-', '+',
'FILTER') # missing args
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', '-', '+',
'RETLIF') # no filter word
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', 'string',
start_ts + samples_count, 'FILTER',
'generation=x')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts, 'string', 'FILTER',
'generation=x')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'FILTER',
'generation+x')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'FILTER',
'generation!=x')
# issue 414
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'FILTER',
'name=(bob,rudy,)')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'FILTER',
'name=(bob,,rudy)')
# test SELECTED_LABELS
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'SELECTED_LABELS', 'filter', 'k!=5')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'SELECTED_LABELS', 'filter', 'k!=5')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count,
'SELECTED_LABELS', 'WITHLABELS', 'filter',
'k!=5')
with pytest.raises(redis.ResponseError) as excinfo:
assert r.execute_command('TS.mrange', start_ts,
start_ts + samples_count, 'WITHLABELS',
'SELECTED_LABELS', 'filter', 'k!=5')
def test_rename_src():
env = Env()
with env.getClusterConnectionIfNeeded() as r:
assert r.execute_command('TS.CREATE', 'a1{1}')
assert r.execute_command('TS.CREATE', 'b{1}')
env.assertTrue(r.execute_command('RENAME', 'a1{1}', 'a2{1}'))
aInfo = TSInfo(r.execute_command('TS.INFO', 'a2{1}'))
env.assertEqual(aInfo.sourceKey, None)
env.assertEqual(aInfo.rules, [])
assert r.execute_command('TS.CREATERULE', 'a2{1}', 'b{1}',
'AGGREGATION', 'AVG', 5000)
bInfo = TSInfo(r.execute_command('TS.INFO', 'b{1}'))
env.assertEqual(bInfo.sourceKey, b'a2{1}')
env.assertEqual(bInfo.rules, [])
env.assertTrue(r.execute_command('RENAME', 'a2{1}', 'a3{1}'))
bInfo = TSInfo(r.execute_command('TS.INFO', 'b{1}'))
env.assertEqual(bInfo.sourceKey, b'a3{1}')
env.assertEqual(bInfo.rules, [])
