def test_delete_entity_with_tenancy(translator):
entities = create_random_entities(num_types=2,
num_ids_per_type=2,
num_updates=5)
fs = 'fs'
fsp = 'fsp'
translator.insert(entities, fiware_service=fs, fiware_servicepath=fsp)
to_delete = entities[0]
deleted_type = to_delete['type']
deleted_id = to_delete['id']
# No fs nor fsp -> no deletion
res = translator.delete_entity(deleted_id, entity_type=deleted_type)
assert res == 0
# No fsp -> no deletion
res = translator.delete_entity(deleted_id,
entity_type=deleted_type,
fiware_service=fs)
assert res == 0
# Matching fs & fsp -> deletion
res = translator.delete_entity(deleted_id,
entity_type=deleted_type,
fiware_service=fs,
fiware_servicepath=fsp)
assert res == 5
translator.clean(fs)
def test_delete_entity_customs(translator):
entities = create_random_entities(num_types=1,
num_ids_per_type=2,
num_updates=10)
for i, e in enumerate(entities):
t = datetime(2018, 1, 1 + i).isoformat(timespec='milliseconds')
e[TIME_INDEX_NAME] = t
translator.insert(entities)
deleted_type = entities[-1]['type']
deleted_id = entities[-1]['id']
res = translator.delete_entity(entity_id=deleted_id,
entity_type=deleted_type,
from_date=datetime(2018, 1, 8).isoformat(),
to_date=datetime(2018, 1, 16).isoformat())
assert res == 5
affected, err = translator.query(
entity_id=deleted_id, entity_type=deleted_type)
assert len(affected) == 1
affected = affected[0]
assert affected['id'] == deleted_id
assert affected['type'] == deleted_type
assert len(affected['index']) == 10 - 5
res, err = translator.query(entity_type=deleted_type)
assert len(res) == 2
unaffected = res[0] if res[0]['id'] != deleted_id else res[1]
assert unaffected['id'] != deleted_id
assert unaffected['type'] == deleted_type
assert len(unaffected['index']) == 10
translator.clean()
def test_delete_entity_defaults(translator):
num_types = 2
num_ids_per_type = 2
num_updates = 5
entities = create_random_entities(num_types, num_ids_per_type, num_updates)
translator.insert(entities)
deleted_type = entities[0]['type']
deleted_id = entities[0]['id']
total, err = translator.query()
assert len(total) == num_types * num_ids_per_type
selected, err = translator.query(
entity_type=deleted_type, entity_id=deleted_id)
assert len(selected[0]['index']) == num_updates
n_deleted = translator.delete_entity(deleted_id, entity_type=deleted_type)
assert n_deleted == num_updates
remaining, err = translator.query()
assert len(remaining) == (len(total) - 1)
survivors, err = translator.query(
entity_type=deleted_type, entity_id=deleted_id)
assert len(survivors) == 0
translator.clean()
def test_query_multiple_ids_bak(translator):
# Should not break old usage of one single entity_id
num_updates = 3
entities = create_random_entities(num_types=2,
num_ids_per_type=4,
num_updates=num_updates)
translator.insert(entities)
records = translator.query(entity_type='0', entity_ids=['0-1'])
assert len(records) == 1
assert records[0]['id'] == '0-1'
translator.clean()
def benchmark(translator, num_types=10, num_ids_per_type=10, num_updates=10, use_time=False, use_geo=False):
from utils.tests.common import create_random_entities, pick_random_entity_id
results = {}
entities = create_random_entities(num_types, num_ids_per_type, num_updates, use_time=use_time, use_geo=use_geo)
# Insert 1 entity
res = timeit.timeit(partial(translator.insert, entities=entities[:1]), number=1, globals=globals())
results[BM_INSERT_1E] = res
# Insert N entities
n = min(1000, num_types * num_ids_per_type * num_updates//10)
res = timeit.timeit(partial(translator.insert, entities=entities[1:n]), number=1, globals=globals())
results[BM_INSERT_NE] = res
# Insert the rest to have data to query
translator.insert(entities=entities[n:])
time.sleep(1)
random_id = pick_random_entity_id(num_types, num_ids_per_type)
entity_type = random_id[0]
# Query 1 attr of 1 entity
res = timeit.timeit(partial(translator.query, attr_names=['attr_str'], entity_type=entity_type, entity_id=random_id),
number=1, globals=globals())
results[BM_QUERY_1A1E] = res
# Query all attrs of 1 entity
res = timeit.timeit(partial(translator.query, entity_type=entity_type, entity_id=random_id), number=1, globals=globals())
results[BM_QUERY_NA1E] = res
# Query 1 attr of N entities
res = timeit.timeit(partial(translator.query, attr_names=['attr_str']), number=1, globals=globals())
results[BM_QUERY_1ANE] = res
# Query all attrs of N entities
res = timeit.timeit(partial(translator.query), number=1, globals=globals())
results[BM_QUERY_NANE] = res
# Query aggregate on 1 entity (Needs multiple inserts for the same entity)
res = timeit.timeit(partial(translator.average, attr_name="attr_float", entity_type=entity_type, entity_id=random_id),
number=1, globals=globals())
results[BM_AGGREGATE_1A1E] = res
# Query aggregate on all entities
res = timeit.timeit(partial(translator.average, attr_name="attr_float"), number=1, globals=globals())
results[BM_AGGREGATE_1ANE] = res
return results
def test_delete_entities_defaults(translator):
entities = create_random_entities(num_types=3,
num_ids_per_type=2,
num_updates=20)
translator.insert(entities)
type_to_delete = entities[0]['type']
res = translator.delete_entities(type_to_delete)
assert res == 20 * 2
remaining, err = translator.query()
assert len(remaining) == (3 - 1) * 2
assert all([r['type'] != type_to_delete for r in remaining])
translator.clean()
def test_query_multiple_ids_with_invalids(translator):
# Nonexistent ids should be ignored
num_updates = 3
entities = create_random_entities(num_types=2,
num_ids_per_type=4,
num_updates=num_updates)
translator.insert(entities)
loaded_entities = translator.query(entity_type='0',
entity_ids=['nonexistent'])
assert len(loaded_entities) == 0
loaded_entities = translator.query(entity_type='0',
entity_ids=['0-1', 'nonexistent'])
assert len(loaded_entities) == 1
translator.clean()
def test_aggr_per_second(translator):
entities = create_random_entities(num_ids_per_type=2, num_updates=17)
assert len(entities) == 34
# One update every 100 millis -> 10 updates per second.
base_index = datetime.datetime(2010, 1, 1, 8, 0, 0, 0,
datetime.timezone.utc)
delta = datetime.timedelta(milliseconds=100)
for i, e in enumerate(entities):
t = base_index + i * delta
e[TIME_INDEX_NAME] = t.isoformat(timespec='milliseconds')
add_attr(e, 'attr_float', i)
translator.insert(entities)
# Query avg attr_float per second.
res = translator.query(attr_names=['attr_float'],
aggr_method='avg',
aggr_period='second')
assert len(res) == 2
# 34 values span across 4 seconds
expected_index = []
for i in range(4):
d = datetime.datetime(2010, 1, 1, 8, 0, i, 0, datetime.timezone.utc)
expected_index.append(d.isoformat(timespec='milliseconds'))
assert res[0] == {
'type': '0',
'id': '0-0',
'index': expected_index,
'attr_float': {
'type': 'Number',
'values': [4, 14, 24, 31],
}
}
assert res[1] == {
'type': '0',
'id': '0-1',
'index': expected_index,
'attr_float': {
'type': 'Number',
'values': [5, 15, 25, 32],
}
}
translator.clean()
def test_query_multiple_ids(translator):
# First insert some data
num_updates = 3
entities = create_random_entities(num_types=2,
num_ids_per_type=4,
num_updates=num_updates)
translator.insert(entities)
loaded_entities = translator.query(entity_type='0',
entity_ids=['0-0', '0-2'])
assert len(loaded_entities) == 2
# All results are of type 0 and cannot be of a non-requested id.
assert loaded_entities[0]['id'] == '0-0'
assert loaded_entities[0]['type'] == '0'
assert loaded_entities[1]['id'] == '0-2'
assert loaded_entities[1]['type'] == '0'
translator.clean()
def test_delete_entities_customs(translator):
entities = create_random_entities(num_types=4,
num_ids_per_type=1,
num_updates=4)
for i, e in enumerate(entities):
time_index = datetime(2018, 1, 1 + i).isoformat()[:-3]
e[TIME_INDEX_NAME] = time_index
translator.insert(entities)
type_to_delete = entities[-1]['type']
res = translator.delete_entities(type_to_delete,
from_date=datetime(
2018, 1, 4).isoformat(),
to_date=datetime(2018, 1, 12).isoformat())
assert res == 3
remaining, err = translator.query()
assert sum([len(r['index']) for r in remaining]) == ((4 * 4) - 3)
translator.clean()
def test_delete_entities_with_tenancy(translator):
fs = 'fs'
fsp = 'fsp'
entities = create_random_entities(num_types=3,
num_ids_per_type=1,
num_updates=10)
translator.insert(entities, fiware_service=fs, fiware_servicepath=fsp)
type_to_delete = entities[0]['type']
res = translator.delete_entities(type_to_delete)
assert res == 0
res = translator.delete_entities(type_to_delete,
fiware_service=fs,
fiware_servicepath='another/path')
assert res == 0
res = translator.delete_entities(type_to_delete,
fiware_service=fs,
fiware_servicepath=fsp)
assert res == 10
translator.clean(fs)
