def test_version_in():
from whoosh import __version__
from whoosh import index
with TempStorage("versionin") as st:
assert not index.exists(st)
schema = fields.Schema(text=fields.TEXT)
ix = st.create_index(schema)
assert index.exists(st)
assert ix.is_empty()
v = index.version(st)
assert v[0] == __version__
assert v[1] == index._CURRENT_TOC_VERSION
with ix.writer() as w:
w.add_document(text=u("alfa"))
assert not ix.is_empty()
def test_fields():
with TempStorage() as st:
f = st.create_file("test")
gw = fst.GraphWriter(f)
gw.start_field("f1")
gw.insert("a")
gw.insert("aa")
gw.insert("ab")
gw.finish_field()
gw.start_field("f2")
gw.insert("ba")
gw.insert("baa")
gw.insert("bab")
gw.close()
gr = fst.GraphReader(st.open_file("test"))
cur1 = fst.Cursor(gr, gr.root("f1"))
cur2 = fst.Cursor(gr, gr.root("f2"))
assert list(cur1.flatten_strings()) == ["a", "aa", "ab"]
assert list(cur2.flatten_strings()) == ["ba", "baa", "bab"]
gr.close()
def _roundtrip(content, format_, astype, ana=None):
with TempStorage("roundtrip") as st:
codec = default_codec()
seg = codec.new_segment(st, "")
ana = ana or analysis.StandardAnalyzer()
field = fields.FieldType(format=format_, analyzer=ana)
fw = codec.field_writer(st, seg)
fw.start_field("f1", field)
for text, _, weight, valuestring in sorted(field.index(content)):
fw.start_term(text)
fw.add(0, weight, valuestring, None)
fw.finish_term()
fw.finish_field()
fw.close()
tr = codec.terms_reader(st, seg)
ps = []
for fieldname, btext in tr.terms():
m = tr.matcher(fieldname, btext, format_)
ps.append((field.from_bytes(btext), m.value_as(astype)))
tr.close()
return ps
def test_random():
def randstring():
length = random.randint(1, 5)
a = array("B", (random.randint(0, 255) for _ in xrange(length)))
return array_tobytes(a)
keys = sorted(randstring() for _ in xrange(100))
with TempStorage() as st:
gwrite(keys, st)
gr = greader(st)
cur = fst.Cursor(gr)
s1 = cur.flatten()
s2 = sorted(set(keys))
for i, (k1, k2) in enumerate(zip(s1, s2)):
assert k1 == k2, "%s: %r != %r" % (i, k1, k2)
sample = list(keys)
random.shuffle(sample)
for key in sample:
cur.reset()
cur.find_path(key)
assert cur.prefix_bytes() == key
gr.close()
def test_closed_searcher():
from whoosh.reading import ReaderClosed
schema = fields.Schema(key=fields.KEYWORD(stored=True, sortable=True,
spelling=True))
with TempStorage() as st:
ix = st.create_index(schema)
with ix.writer() as w:
w.add_document(key=u("alfa"))
w.add_document(key=u("bravo"))
w.add_document(key=u("charlie"))
w.add_document(key=u("delta"))
w.add_document(key=u("echo"))
s = ix.searcher()
r = s.search(query.TermRange("key", "b", "d"))
s.close()
assert s.is_closed
with pytest.raises(ReaderClosed):
assert r[0]["key"] == "bravo"
with pytest.raises(ReaderClosed):
s.reader().column_reader("key")
with pytest.raises(ReaderClosed):
s.reader().has_word_graph("key")
with pytest.raises(ReaderClosed):
s.suggest("key", "brovo")
s = ix.searcher()
r = s.search(query.TermRange("key", "b", "d"))
assert r[0]
assert r[0]["key"] == "bravo"
c = s.reader().column_reader("key")
assert c[1] == "bravo"
assert s.reader().has_word_graph("key")
assert s.suggest("key", "brovo") == ["bravo"]
def test_simple_compound_mmap():
with TempStorage("compound") as st:
assert st.supports_mmap
_test_simple_compound(st)