def test_block_aggregate_schema_evaluate_without_split(
block_aggregate_schema_spec, schema_loader):
name = schema_loader.add_schema_spec(block_aggregate_schema_spec)
block_aggregate_schema = BlockAggregateSchema(name, schema_loader)
identity = 'userA'
time = datetime(2018, 3, 7, 19, 35, 31, 0, timezone.utc)
block_aggregate = create_block_aggregate(block_aggregate_schema, time,
identity)
block_aggregate.run_evaluate()
# Check eval results of various fields
assert len(block_aggregate._nested_items) == 4
assert check_fields(
block_aggregate._nested_items, {
'_identity': identity,
'event_count': 1,
'_start_time': time,
'_end_time': time
})
# aggregate snapshot should not exist in store
assert block_aggregate._store.get(
Key(identity=block_aggregate._identity,
group=block_aggregate._name,
timestamp=block_aggregate._start_time)) is None
def test_block_aggregate_schema_initialization(schema_spec, store_spec):
schema_loader = SchemaLoader()
name = schema_loader.add_schema_spec(schema_spec)
schema_loader.add_schema_spec(store_spec, name)
schema = BlockAggregateSchema(name, schema_loader)
assert match_fields(schema._spec['Fields'])
loader_spec = schema_loader.get_schema_spec(name)
assert match_fields(loader_spec['Fields'])
def test_block_aggregate_schema_missing_split_attribute_adds_error(
schema_spec, store_spec):
del schema_spec[BlockAggregateSchema.ATTRIBUTE_SPLIT]
schema_loader = SchemaLoader()
name = schema_loader.add_schema_spec(schema_spec)
schema_loader.add_schema_spec(store_spec, name)
schema = BlockAggregateSchema(name, schema_loader)
assert 1 == len(schema.errors)
assert isinstance(schema.errors[0], RequiredAttributeError)
assert BlockAggregateSchema.ATTRIBUTE_SPLIT == schema.errors[0].attribute
def test_block_aggregate_schema_with_split_initialization(
schema_spec, store_spec):
schema_spec['Split'] = '4 > 2'
schema_loader = SchemaLoader()
name = schema_loader.add_schema_spec(schema_spec)
schema_loader.add_schema_spec(store_spec, name)
schema = BlockAggregateSchema(name, schema_loader)
assert isinstance(schema.split, Expression)
assert match_fields(schema_spec['Fields'])
loader_spec = schema_loader.get_schema_spec(name)
assert match_fields(loader_spec['Fields'])
def test_block_aggregate_schema_evaluate_with_dimensions(
block_aggregate_schema_spec, schema_loader):
block_aggregate_schema_spec['Dimensions'] = [{
'Name': 'label',
'Type': Type.STRING,
'Value': 'source.label'
}]
name = schema_loader.add_schema_spec(block_aggregate_schema_spec)
block_aggregate_schema = BlockAggregateSchema(name, schema_loader)
identity = 'userA'
time = datetime(2018, 3, 7, 19, 35, 31, 0, timezone.utc)
block_aggregate = create_block_aggregate(block_aggregate_schema, time,
identity)
block_aggregate._evaluation_context.global_add('source',
Record({'label': 'label1'}))
block_aggregate.run_evaluate()
block_aggregate.run_evaluate()
# Check eval results of various fields before split
assert check_fields(
block_aggregate._nested_items, {
'_identity': identity,
'event_count': 2,
'_start_time': time,
'_end_time': time,
'label': 'label1',
})
current_snapshot = block_aggregate._snapshot
block_aggregate._evaluation_context.global_add('source',
Record({'label': 'label2'}))
block_aggregate.run_evaluate()
# Check eval results of various fields
assert check_fields(
block_aggregate._nested_items, {
'_identity': identity,
'event_count': 1,
'_start_time': time,
'_end_time': time,
'label': 'label2',
})
# Check aggregate snapshot present in store
assert block_aggregate._store.get(
Key(key_type=KeyType.DIMENSION,
identity=block_aggregate._identity,
group=block_aggregate._name,
dimensions=['label1'])) == current_snapshot
def block_schema(schema_loader: SchemaLoader) -> BlockAggregateSchema:
name = schema_loader.add_schema_spec({
'Type':
Type.BLURR_AGGREGATE_BLOCK,
'Name':
'session',
'Fields': [
{
'Name': 'events',
'Type': Type.INTEGER,
'Value': 'session.events + 1',
},
],
})
return BlockAggregateSchema(name, schema_loader)
def test_block_aggregate_schema_initialization(schema_spec, store_spec):
schema_loader = SchemaLoader()
name = schema_loader.add_schema_spec(schema_spec)
schema_loader.add_schema_spec(store_spec, name)
schema = BlockAggregateSchema(name, schema_loader)
assert schema._spec[BlockAggregateSchema.ATTRIBUTE_DIMENSIONS] == [{
'Name':
'label',
'Type':
Type.STRING,
'Value':
'source.label'
}]
assert match_fields(schema._spec['Fields'])
loader_spec = schema_loader.get_schema_spec(name)
assert match_fields(loader_spec['Fields'])
def test_block_aggregate_schema_evaluate_with_split(
block_aggregate_schema_spec, schema_loader):
block_aggregate_schema_spec['Split'] = 'user.event_count == 2'
name = schema_loader.add_schema_spec(block_aggregate_schema_spec)
block_aggregate_schema = BlockAggregateSchema(name, schema_loader)
identity = 'userA'
time = datetime(2018, 3, 7, 19, 35, 31, 0, timezone.utc)
block_aggregate = create_block_aggregate(block_aggregate_schema, time,
identity)
block_aggregate.run_evaluate()
block_aggregate.run_evaluate()
# Check eval results of various fields before split
assert check_fields(
block_aggregate._nested_items, {
'_identity': identity,
'event_count': 2,
'_start_time': time,
'_end_time': time
})
current_snapshot = block_aggregate._snapshot
block_aggregate.run_evaluate()
# Check eval results of various fields
assert check_fields(
block_aggregate._nested_items, {
'_identity': identity,
'event_count': 1,
'_start_time': time,
'_end_time': time
})
# Check aggregate snapshot present in store
assert block_aggregate._store.get(
Key(identity=block_aggregate._identity,
group=block_aggregate._name,
timestamp=time)) == current_snapshot