Example #1
0
def test_tagged_dim_matchs():
    # not in table metadata
    assert_true(not tm.tagged_dim_matches(tagged_dim(':'), Field('ip_addr')))

    assert_true(tm.tagged_dim_matches(tagged_dim(':'), Field('clientip')))
    assert_true(tm.tagged_dim_matches(tagged_dim(':ip'), Field('clientip')))
    assert_true(
        not tm.tagged_dim_matches(tagged_dim(':mac'), Field('clientip')))
Example #2
0
def test_field_selector():
    assert_equal(field_or_tagged_dim(' @f '), Field('f'))
    assert_equal(field_or_tagged_dim(Field('f')), Field('f'))

    assert_equal(field_or_tagged_dim('tag:dim'), tagged_dim('tag:dim'))
    assert_equal(field_or_tagged_dim(['tag', 'dim']), tagged_dim('tag:dim'))

    assert_equal(field_or_tagged_dim(tagged_dim('tag:dim')),
                 tagged_dim('tag:dim'))
Example #3
0
def test_parse_tagdim_field_list_fields1():
    def f(x):
        res = parse_list_fieldselectors(x)
        return res

    assert_equal(f("*"), [])
    assert_equal(f(""), [])
    assert_equal(f("@F"), [Field('F')])
    assert_equal(f("@F,@G"), [Field('F'), Field('G')])
    assert_equal(f(":dim"), [tagged_dim("dim")])
    assert_equal(f("tag:,:dim"), [tagged_dim('tag:'), tagged_dim("dim")])
Example #4
0
def test_ds_rewrite_tagged_dim_to_or():
    c = gbceq(tagged_dim(':ip'), '1.2.3.4')
    r = ds._rewrite_tagged_dim(c)
    expected = Or([
        gbceq(Field('clientip'), '1.2.3.4'),
        gbceq(Field('serverip'), '1.2.3.4')
    ])
    assert_equal(expected, r)
Example #5
0
def test_parse_tagged_dim():
    assert_equal(tagged_dim(['tag1', 'dim']),
                 TaggedDim(dim=Dim('dim'), tags=[Tag('tag1')]))
    assert_equal(tagged_dim('dim'), TaggedDim(dim=Dim('dim')))
    assert_equal(tagged_dim(':dim'), TaggedDim(dim=Dim('dim')))
    assert_equal(tagged_dim('tag1:'), TaggedDim(tags=[Tag('tag1')]))
    assert_equal(tagged_dim('tag1:dim'),
                 TaggedDim(dim=Dim('dim'), tags=[Tag('tag1')]))
    assert_equal(tagged_dim('tag1:tag2:dim'),
                 TaggedDim(dim=Dim('dim'), tags=[Tag('tag1'),
                                                 Tag('tag2')]))
Example #6
0
def test_tagged_dim_to_dict():
    t = tagged_dim("tag1:dim")
    assert_equal({'tags': ['tag1'], 'dim': 'dim'}, t.to_dict())
Example #7
0
def test_or_repr():
    c = Or([Equals(tagged_dim('src:ip'), 2)])
    assert_equal( c , eval(repr(c)))
Example #8
0
def test_tagged_dim_badarg():
    tagged_dim(1)
Example #9
0
def test_tagged_dim_repr():
    t = tagged_dim("tag1:dim")
    assert_equal(t, eval(repr(t)))
Example #10
0
def test_fields_matching():
    assert_equal(tm.fields_matching(Field('clientip')), [Field('clientip')])
    assert_equal(tm.fields_matching('@clientip'), [Field('clientip')])
    assert_equal(tm.fields_matching(tagged_dim(':ip')), [Field('clientip')])
    assert_equal(tm.fields_matching(tagged_dim(':mac')), [])
Example #11
0
def test_ds_rewrite_tagged_dim_nogbc():
    c = Equals(tagged_dim(':ip'), '1.2.3.4')
    r = ds._rewrite_tagged_dim(c)
    assert_equal(c, r)
Example #12
0
def test_ds_rewrite_tagged_dim_no_fields():
    c = gbceq(tagged_dim(':mac'), '1:2:3:4:5:6')
    # No fields have dimension=mac
    ds._rewrite_tagged_dim(c)
Example #13
0
def test_bc_repr():
    c = BinaryCondition(tagged_dim('t:d'), 2)
    assert_equal( c , eval(repr(c)))
Example #14
0
def test_parse_field():
    print(tagged_dim('@Field'))
Example #15
0
def test_gteq_repr():
    c = GreaterThanEqualTo(tagged_dim('t:d'), 2)
    assert_equal( c , eval(repr(c)))
Example #16
0
def test_matches_repr():
    c = MatchesCond(tagged_dim('t:d'), 2)
    assert_equal( c , eval(repr(c)))
Example #17
0
def test_equals_repr():
    c = Equals(tagged_dim('t:d'), 2)
    assert_equal( c , eval(repr(c)))
Example #18
0
def test_gbc_repr():
    c = GenericBinaryCondition(tagged_dim('t:d'), '==', 2)
    assert_equal( c , eval(repr(c)))
Example #19
0
def test_tm_tdselect():
    assert_true(tm._tagged_dim_subset(tagged_dim(':'), tagged_dim('src:ip')))
    assert_true(tm._tagged_dim_subset(tagged_dim(':ip'), tagged_dim('src:ip')))
    assert_true(
        not tm._tagged_dim_subset(tagged_dim(':mac'), tagged_dim('src:ip')))

    assert_true(tm._tagged_dim_subset(tagged_dim('src:'),
                                      tagged_dim('src:ip')))
    assert_true(
        not tm._tagged_dim_subset(tagged_dim('src:mac'), tagged_dim('src:ip')))
    assert_true(not tm._tagged_dim_subset(tagged_dim('src:nat:ip'),
                                          tagged_dim('src:ip')))

    assert_true(tm._tagged_dim_subset(tagged_dim('src:'), tagged_dim('src:')))
    assert_true(
        tm._tagged_dim_subset(tagged_dim('src:'), tagged_dim('src:nat:')))
Example #20
0
from scape.registry.tagged_dim import tagged_dim
from scape.registry.condition import (
    Equals, MatchesCond, TrueCondition, 
    GreaterThan, GreaterThanEqualTo, 
    And, Or, 
)
from scape.registry.table_metadata import TableMetadata
from scape.registry.data_source import DataSource

weblog_metadata = TableMetadata({
    'clientip' : tagged_dim('client:ip'),
    'serverip' : tagged_dim('server:ip'),
    'url' : tagged_dim('http:url'),
    'status_code' : tagged_dim('http:status_code'),
    'time': tagged_dim('sec')
})

weblog_data = [ {
    'clientip' : '1.2.3.4',
    'serverip' : '4.4.4.4',
    'url' : 'http://foo.bar.com/index.html',
    'status_code' : '404',
    'time' : '03-31-2011 08:11:22'
},  {
    'clientip' : '7.8.9.2',
    'serverip' : '4.4.4.4',
    'url' : 'http://foo.bar.com/status.html',
    'status_code' : '200',
    'time' : '03-31-2011 08:14:33'
}, {
    'clientip' : '1.2.3.4',