def test_par_construction(query1, query2):
s1 = stream("1")
s2 = stream("2")
evt1 = event(V.foo == query1)
evt2 = event(V.foo == query2)
assume( isinstance(any_of(s1(evt1), s2(evt2)), Par) )
assume( isinstance(all_of(s1(evt1), s2(evt2)), Par) )
def test_simple_spans(query):
s1 = stream("1")
s2 = stream("2")
sp1 = span(s1.foo == query, s2.foo == query)
sp2 = span(s1.foo == query, s2.foo == query, within=delta(days=2))
assume(type(sp1) is Span)
assume(type(sp2) is Span)
def test_serial_construction(query1, query2):
s1 = stream("1")
s2 = stream("2")
evt1 = event(V.foo == query1)
evt2 = event(V.foo == query2)
srl = span(s1(evt1)) \
.then(s2(evt2), within=delta(days=5))
assume(type(srl) is Serial)
def test_overloaded_ops(query):
s1 = stream("1")
s2 = stream("2")
span1 = span(s2.foo == query)
span2 = span(s1.foo == query)
assume(type(span1) == Span and type(span2) == Span)
assume(type(span1 & span2) == Span)
assume(type(span1 | span2) == Or)
assume(type(span1 >>span2) == Serial)
def test_stream_equality(name):
class StreamStub:
_name = name
def __init__(self):
pass
s1 = stream(name)
s2 = stream(name)
s3 = stream(name + " lies")
assume(stream(name) == StreamStub())
assume(s1 == s2)
assume(not s1 is s2)
assume(not (s1 == s3))
def test_merge_construction():
s = stream("1")
evt = event(V.foo == 1) >> event(V.bar == 2)
span1 = span(s(evt), within=delta(days=1))
span2 = span(s(evt), within=delta(days=2))
assume(merge(span1, span2))
def test_switch_construction(query1, query2):
spike = event(V.foo == query1) >> event(V.bar < query2) >> event(
V.baz != query1)
assume(isinstance(spike, Switch))
s = stream("1")
assume(isinstance(s(spike), Switch))
def test_select_with_bounds():
s = stream("1")
# FIXME: using this as a span returns a TypeError
evt = event(V.foo == 1)
sel = select(start=datetime.now(), end=datetime.now()) \
.span(s.evt == 1) \
.then(s.evt == 2)
#.span(s(evt) >> s(evt)) \
#.then(s(evt))
assume(isinstance(sel, Select))
assume(type(sel()) == dict)
sel = select(end=datetime.now()) \
.span(s.evt == 1) \
.then(s.evt == 2)
#.span(s(evt) >> s(evt)) \
#.then(s(evt))
assume(isinstance(sel, Select))
assume(type(sel()) == dict)
sel = select(start=datetime.now()) \
.span(s.evt == 1) \
.then(s.evt == 2)
#.span(s(evt) >> s(evt)) \
#.then(s(evt))
assume(isinstance(sel, Select))
assume(type(sel()) == dict)
def test_select_construction(query1, query2):
s1 = stream("1")
s2 = stream("2")
evt1 = event(V.foo == query1)
evt2 = event(V.foo == query2)
sel0 = select() \
.span(s1(evt1))
assume(isinstance(sel0, Select))
sel1 = select() \
.span(s1(evt1) >> s2(evt2))
assume(isinstance(sel1, Select))
sel3 = select() \
.span(all_of(s1(evt1), s2(evt2)))
assume(isinstance(sel3, Select))
sel4 = select() \
.span((s1(evt1), s2(evt2))) \
.then(s2(evt1))
assume(isinstance(sel4, Select))
def test_delete_with_eid(eid):
s = stream("foo")
def mock_encodings(m, quoter):
try:
m.delete(URL_EVENTS_ID.format(s['name'], quoter(eid)))
except:
pass
with requests_mock.mock() as m:
mock_encodings(m, lambda x: x)
mock_encodings(m, quote)
mock_encodings(m, lambda x: quote(x.encode('utf-8', 'ignore')))
assume(test_client.delete(s, eid) == None)
def check_syntax_with_type(query, is_multitype=False):
s = stream("")
assume_parsable(s.foo.bar.baz.qux == query)
assume_parsable(s.foo.bar.baz.qux > query)
assume_parsable(s.foo.bar.baz.qux >= query)
assume_parsable(s.foo.bar.baz.qux < query)
assume_parsable(s.foo.bar.baz.qux <= query)
assume_parsable(s.foo.bar.baz.qux != query)
with pytest.raises(TypeError):
s.foo >> query
with pytest.raises(TypeError):
s.foo << query
if is_multitype:
pass
#assume_parsable(s.foo in query)
#with pytest.raises(TypeError):
# s.foo in query
else:
with pytest.raises(TypeError):
s.foo in query
def test_inpoly():
s = stream("")
inpoly = inside_region(Polygon([(0, 0), (1, 1), (1, 0)]))
assert_parsable(s.foo == inpoly)
def test_incircle(kmx, kmy, rad):
s = stream("")
incircle = within_distance(rad, Point(kmx, kmy))
assume_parsable(s.foo == incircle)
def test_text_regex():
s = stream("")
assume_parsable(s.foo == r'')
def test_text_wildcard():
s = stream("")
assume_parsable(s.foo == "test*")
def test_stream_properties(name, meta):
s = stream(name, meta)
assume(s.name == name)
s._set(name + " new")
assume(s.name == name + " new")
assume(s.meta == meta)
def test_happy_stream_getitems(name, meta):
s = stream(name, meta)
assume(s["meta"] == meta)
assume(s["name"] == name)
def test_sad_stream_getitems(extra):
s = stream("")
with pytest.raises(KeyError):
s[extra]
def test_named_streams(name):
s = stream(name)
assume(s._name == name)
def test_stream_calls(path):
s = stream("")
with pytest.raises(TypeError):
s(path)
def test_stream_path_conversions(path):
s = stream("")
assume(type(s._(path)) == StreamPath)
assume(type(s.__getattr__(path)) == StreamPath)
def test_stream_to_string(name):
""" TODO: there are some behaviors around str() which could be tested """
to_str = str(stream(name))
pass
