def test_create_errors(monkeypatch):
with pytest.raises(searching.CantCreateError) as e:
searching.parse_create("asdfsdgsdg")
a = str(e).split("\n")
assert len(a) == 1
assert "full node" in a[0]
with pytest.raises(searching.CantCreateError):
searching.parse_create_single("sgdfgdf")
with pytest.raises(searching.CantCreateError):
searching.parse_create_single("< task: derp")
with pytest.raises(searching.CantCreateError):
searching.parse_create_single("*")
def _hook3(queries):
return queries * 2
monkeypatch.setattr(searching, "parsecreatefilters", [
_hook3
])
with pytest.raises(searching.CantCreateError) as e:
searching.parse_create("asdfsdgsdg")
a = str(e.value).split("\n")
assert len(a) >= 2
assert "full node" in a[-1]
assert "full node" in a[-2]
def test_mini_child_loop(self, tracker, reftype):
tracker.deserialize({"life":
"task: target\n"
"%s: <-" % reftype
})
creator = searching.parse_create(reftype + u"> task: test")
node = creator(tracker.root)
assert node
proxy_task = tracker.root.find(reftype + u"> test").one()
target_task = tracker.root.find(u"target > test").one()
reference = tracker.root.find(reftype).one()
target = tracker.root.find(u"target").one()
unwrap = reference.unwrap
wrap = reference.get_proxy
assert unwrap(reference) is target
assert wrap(target) is reference
assert unwrap(proxy_task) is target_task
assert wrap(target_task) is proxy_task
assert target_task._next_node is target.children
assert target_task._prev_node is target.children
assert proxy_task._next_node is reference.children
assert proxy_task._prev_node is reference.children
assert target_task.parent is target
assert proxy_task.parent is reference
def test_create_node_existing(self):
tracker = Tracker(False)
nodes = []
origin = tracker.root.createchild("task", "origin")
nodes.append(origin.createchild("task", "finished"))
nodes[-1].start()
nodes[-1].finish()
nodes.append(origin.createchild("task", "finished 2"))
nodes[-1].start()
nodes[-1].finish()
nodes.append(origin.createchild("task", "started"))
nodes[-1].start()
nodes.append(origin.createchild("task", "untouched"))
nodes.append(origin.createchild("task", "untouched 2"))
creator = searching.parse_create("task: target")
created = creator(origin)
results = list(origin.children)
assert (results[:2] + results[3:]) == nodes
assert results[2].node_type == "task"
assert results[2].text == "target"
assert created == results[2]
assert repr(creator)
def test_parse_filters(monkeypatch):
def _hook1(queries):
queries.append(searching.parse_single("comment: derp derp"))
return queries
def _hook2(queries):
queries.append(searching.parse_single("task: some random query"))
return queries
monkeypatch.setattr(searching, "parsecreatefilters", [
_hook1,
_hook2
])
assert searching.parse("around the world") == searching.Queries(
searching.parse_single("around the world"),
searching.parse_single("comment: derp derp"),
searching.parse_single("task: some random query"),
)
assert (searching.parse_create("comment: hoop doop") ==
searching._Creators(creators=(
searching.parse_create_single("comment: hoop doop"),
searching.parse_create_single("comment: derp derp"),
searching.parse_create_single("task: some random query")
))
)
def test_proxied_create(self, tracker, reftype):
tracker.deserialize({"life":
u"task: target\n"
u"%s: <-" % reftype
})
creator = searching.parse_create(reftype + u" > task: test")
node = creator(tracker.root)
proxy = tracker.root.find(reftype + u"> test").one()
assert node is proxy
def test_empty_next_peer(self):
tracker = Tracker(False)
origin = tracker.root.createchild("task", "origin")
creator = searching.parse_create("-> task: derp")
creator(origin)
assert match("\n".join(serialize(tracker.root, is_root=True)), (
"task#?????: origin\n"
"task#?????: derp"
))
assert repr(creator)
def test_failed_create(monkeypatch):
tracker = Tracker(False, FakeNodeCreator(GenericActivate))
def _hook2(queries):
return [searching.parse_single("herp > task: derp")] + queries
monkeypatch.setattr(searching, "parsecreatefilters", [
_hook2
])
creator = searching.parse_create("herk derk > task: herk")
with pytest.raises(searching.NodeNotCreated):
creator(tracker.root)
def test_create_node(self):
tracker = Tracker(False, FakeNodeCreator(GenericActivate))
origin = tracker.root.createchild("task", "origin")
creator = searching.parse_create("task: Target")
creator(origin)
assert match("\n".join(serialize(origin)), (
"task#?????: origin\n"
" task#?????: Target"
))
assert repr(creator)
def test_existing_query(self):
tracker = Tracker(False, FakeNodeCreator(GenericActivate))
origin = tracker.root.createchild("task", "origin")
selector = searching.parse_single("task: target")
creator = searching.parse_create(query=selector)
creator(origin)
assert match("\n".join(serialize(origin)), (
"task#?????: origin\n"
" task#?????: target"
))
assert repr(creator)
def test_not_found_creates(monkeypatch):
tracker = Tracker(False, FakeNodeCreator(GenericActivate))
def _hook2(queries):
return [searching.parse_single("herp > task: derp")] + queries
monkeypatch.setattr(searching, "parsecreatefilters", [
_hook2
])
creator = searching.parse_create("task: herpity derpity")
node = creator(tracker.root)
assert node.text == "herpity derpity"
assert tracker.root.find("*").one() is node
tracker.root.createchild("task", "herp")
assert len(tracker.root.children) == 2
node = creator(tracker.root)
assert node.text == "derp"
assert len(tracker.root.children) == 2
assert tracker.root.find("herp > derp").one() is node
def test_last_2(self):
creator = searching.parse_create("-> :{last} > task: target")
tracker = Tracker(False, FakeNodeCreator(GenericActivate))
origin = tracker.root.createchild("task", "origin")
tracker.root.createchild("task", "ignore 1")
tracker.root.createchild("task", "ignore 2")
tracker.root.createchild("task", "ignore 3")
tracker.root.createchild("task", "expected")
creator(origin)
assert match("\n".join(serialize(tracker.root, is_root=True)), (
"task#?????: origin\n"
"task#?????: ignore 1\n"
"task#?????: ignore 2\n"
"task#?????: ignore 3\n"
"task#?????: expected\n"
" task#?????: target"
))
assert repr(creator)
def create(self, *a, **kw):
from treeoflife import searching
creator = searching.parse_create(*a, **kw)
return creator(self)
