def test_tiddler_racing():
def race_tiddlers(bag_name, count=2, intitles=['x', 'z'],
outtitles=['y']):
bag = Bag(bag_name)
store.put(bag)
tiddlers = Tiddlers(store=store)
for title in ['x', 'y', 'z']:
tiddler = Tiddler(title, 'foo')
store.put(tiddler)
tiddlers.add(tiddler)
tiddler = Tiddler('y', 'foo')
store.delete(tiddler)
tids = list(tiddlers)
assert len(tids) == count
for title in intitles:
assert title in [tid.title for tid in tids]
for title in outtitles:
assert title not in [tid.title for tid in tids]
stored_config = config.get('collections.use_memory')
config['collections.use_memory'] = False
race_tiddlers('foo')
config['collections.use_memory'] = True
race_tiddlers('bar', count=3, intitles=['x', 'y', 'z'], outtitles=[])
store.delete(Bag('foo'))
store.delete(Bag('bar'))
config['collections.use_memory'] = stored_config
def make_fake_space(store, name):
def set_policy(policy, private=False):
for policy_attr in policy.attributes:
if policy_attr not in ['read', 'owner']:
setattr(policy, policy_attr, [name])
if private:
policy.read = [name]
public_recipe = Recipe('%s_public' % name)
private_recipe = Recipe('%s_private' % name)
public_bag = Bag('%s_public' % name)
private_bag = Bag('%s_private' % name)
archive_bag = Bag('%s_archive' % name)
set_policy(public_recipe.policy)
set_policy(private_recipe.policy, private=True)
set_policy(public_bag.policy)
set_policy(private_bag.policy, private=True)
set_policy(archive_bag.policy, private=True)
public_recipe.set_recipe([('system', ''), ('tiddlyspace', ''),
('%s_public' % name, '')])
private_recipe.set_recipe([('system', ''), ('tiddlyspace', ''),
('%s_public' % name, ''),
('%s_private' % name, '')])
for entity in [
public_recipe, private_recipe, public_bag, private_bag, archive_bag
]:
store.put(entity)
def profile_listing_tiddlers():
store = Store('text', environ=environ)
environ['tiddlyweb.store'] = store
bag = Bag('profiler')
bag.skinny = True
store.get(bag)
print 'filter', time()
filter_string = 'select=tag:100'
filters, leftovers = parse_for_filters(filter_string, environ)
tiddlers = control.filter_tiddlers_from_bag(bag, filters)
print 'tmp bag', time()
tmp_bag = Bag('tmp_bag', tmpbag=True)
tmp_bag.add_tiddlers(tiddlers)
print 'output', time()
print[tiddler.title for tiddler in control.get_tiddlers_from_bag(tmp_bag)]
#print 'serializer', time()
#serializer = Serializer('wiki', environ)
#print 'wikify', time()
#output = serializer.list_tiddlers(tmp_bag)
print 'done', time()
def test_readable_tiddlers_by_bag():
bagone = Bag('cdentread')
bagone.policy.read = ['cdent']
store.put(bagone)
bagtwo = Bag('fndread')
bagtwo.policy.read = ['fnd']
store.put(bagtwo)
bagthree = Bag('allread')
store.put(bagthree)
count = 0
tiddlers = []
for bag in ['cdent', 'fnd', 'all', 'cdent', 'fnd', 'all', 'notreal']:
count += 1
tiddler = Tiddler('tiddler%s' % count, '%sread' % bag)
tiddler.text = 'narf'
tiddlers.append(tiddler)
usersign = {'name': 'cdent', 'roles': []}
readable = list(readable_tiddlers_by_bag(store, tiddlers, usersign))
assert (['tiddler1', 'tiddler3', 'tiddler4', 'tiddler6',
'tiddler7'] == [tiddler.title for tiddler in readable])
usersign = {'name': 'fnd', 'roles': []}
readable = list(readable_tiddlers_by_bag(store, tiddlers, usersign))
assert (['tiddler2', 'tiddler3', 'tiddler5', 'tiddler6',
'tiddler7'] == [tiddler.title for tiddler in readable])
usersign = {'name': 'GUEST', 'roles': []}
readable = list(readable_tiddlers_by_bag(store, tiddlers, usersign))
assert (['tiddler3', 'tiddler6',
'tiddler7'] == [tiddler.title for tiddler in readable])
def _process_choices(environ, start_response, form):
store = environ['tiddlyweb.store']
user = environ['tiddlyweb.usersign']
tmp_bag = form['tmp_bag'][0]
bag = form['target_bag'][0]
if bag:
bag = Bag(bag)
try:
bag.skinny = True
bag = store.get(bag)
except NoBagError:
return _send_wimport(environ, start_response,
'chosen bag does not exist')
else:
bag = form['new_bag'][0]
bag = _make_bag(environ, bag)
try:
bag.policy.allows(user, 'write')
except (ForbiddenError, UserRequiredError):
return _send_wimport(environ, start_response,
'you may not write to that bag')
tiddler_titles = form['tiddler']
for title in tiddler_titles:
tiddler = Tiddler(title.decode('utf-8', 'ignore'), tmp_bag)
tiddler = store.get(tiddler)
tiddler.bag = bag.name
store.put(tiddler)
tmp_bag = Bag(tmp_bag)
store.delete(tmp_bag)
bagurl = bag_url(environ, bag) + '/tiddlers'
raise HTTP302(bagurl)
def test_search_follow_syntax():
QUERY = u'ftitle:GettingStarted (bag:cdent_public OR bag:fnd_public)'
store.put(Bag(u'fnd_public'))
store.put(Bag(u'cdent_public'))
tiddler = Tiddler(u'GettingStarted', u'fnd_public')
tiddler.text = u'fnd starts'
tiddler.fields[u'house'] = u'treehouse'
tiddler.fields[u'car'] = u'porsche'
store.put(tiddler)
tiddler = Tiddler(u'GettingStarted', u'cdent_public')
tiddler.text = u'cdent starts'
tiddler.fields[u'left-hand'] = u'well dirty'
store.put(tiddler)
tiddler = Tiddler(u'other', u'cdent_public')
tiddler.text = u'cdent starts'
store.put(tiddler)
tiddlers = list(store.search(u'starts'))
assert len(tiddlers) == 3
tiddlers = list(store.search(QUERY))
assert len(tiddlers) == 2
tiddlers = list(store.search(u'cdent starts'))
assert len(tiddlers) == 2
tiddlers = list(store.search(u'fnd starts'))
assert len(tiddlers) == 1
tiddler = list(store.search(u'left-hand:"well dirty"'))
assert len(tiddlers) == 1
def test_store():
"""
An exploratory test to learn how this stuff works.
"""
bag = Bag(u'bar')
bag.policy.owner = u'cdent'
bag.policy.read = [u'cdent']
store.put(bag)
sbag = store.storage.session.query(
sql.sBag).filter(sql.sBag.name == u'bar').one()
assert sbag.name == bag.name
assert sbag.policy.owner == bag.policy.owner
assert sbag.policy.read == u'["cdent"]'
bag_d = Bag(u'bar')
bag_d = store.get(bag_d)
assert bag_d.name == bag.name
assert bag_d.policy.owner == bag.policy.owner
assert bag_d.policy.read == bag.policy.read
tiddler = Tiddler(u'tidlname', bag.name)
tiddler.text = u'foo'
tiddler.modifier = u'nancy'
store.put(tiddler)
stiddler = store.storage.session.query(
sql.sTiddler).filter(sql.sTiddler.title == u'tidlname').filter(
sql.sTiddler.bag_name == u'bar').one()
assert stiddler.title == 'tidlname'
assert stiddler.bag_name == 'bar'
assert len(stiddler.revisions) == 1
tiddler = Tiddler(u'tidlname', bag.name)
tiddler.text = u'foo1'
tiddler.modifier = u'karl'
store.put(tiddler)
stiddler = store.storage.session.query(
sql.sTiddler).filter(sql.sTiddler.title == u'tidlname').filter(
sql.sTiddler.bag_name == u'bar').one()
assert stiddler.title == u'tidlname'
assert stiddler.bag_name == u'bar'
assert len(stiddler.revisions) == 2
tiddler_d = Tiddler(u'tidlname', u'bar')
tiddler_d = store.get(tiddler_d)
assert tiddler_d.text == tiddler.text
assert tiddler_d.modifier == u'karl'
assert tiddler_d.creator == u'nancy'
tiddlers = store.list_tiddler_revisions(tiddler_d)
assert len(tiddlers) == 2
store.delete(tiddler_d)
def clear_store():
try:
store.delete(Bag("notfoo"))
except NoBagError:
pass
try:
store.delete(Bag("foo"))
except NoBagError:
pass
def test_put_get_bag():
bag = Bag('testone')
bag.policy.read = ['cdent']
store.put(bag)
read_bag = Bag('testone')
read_bag.skinny = True
read_bag = store.get(read_bag)
assert read_bag.policy.read == ['cdent']
def test_bag_etag():
"""
Explicitly test bag_etag method (not used by the core code).
"""
bag1 = Bag('foo')
bag1.desc = 'desc'
bag2 = Bag('foo')
bag2.desc = 'desc'
assert bag_etag(environ, bag1) == bag_etag(environ, bag2)
def test_handle_empty_policy():
bag = Bag(u'empty')
store.put(bag)
new_bag = store.get(Bag(u'empty'))
assert new_bag.policy.read == []
assert new_bag.policy.manage == []
assert new_bag.policy.create == []
assert new_bag.policy.write == []
assert new_bag.policy.accept == []
assert new_bag.policy.owner == None
def test_store_bag():
bag_in = Bag('bagone')
bag_in.desc = 'bag description'
bag_in.policy.read = ['reader']
bag_in.policy.write = ['writer']
store.put(bag_in)
bag_out = store.get(Bag('bagone'))
assert bag_out.name == bag_in.name
def setup_module(module):
module.store = Store(config['server_store'][0],
config['server_store'][1],
environ={'tiddlyweb.config': config})
try:
bag = Bag('holder')
store.delete(bag)
except:
pass
bag = Bag('holder')
module.store.put(bag)
def test_delete_member():
cookie = get_auth('fnd', 'bird')
http = httplib2.Http()
response, content = http.request(
'http://0.0.0.0:8080/spaces/extra/members/psd',
method='DELETE',
)
assert response['status'] == '403'
response, content = http.request(
'http://extra.0.0.0.0:8080/spaces/extra/members/psd',
method='DELETE',
)
assert response['status'] == '403'
response, content = http.request(
'http://0.0.0.0:8080/spaces/extra/members/psd',
headers={'Cookie': 'tiddlyweb_user="******"' % cookie},
method='DELETE',
)
assert response['status'] == '403'
response, content = http.request(
'http://extra.0.0.0.0:8080/spaces/extra/members/psd',
headers={'Cookie': 'tiddlyweb_user="******"' % cookie},
method='DELETE',
)
assert response['status'] == '204'
# delete self
response, content = http.request(
'http://extra.0.0.0.0:8080/spaces/extra/members/fnd',
headers={'Cookie': 'tiddlyweb_user="******"' % cookie},
method='DELETE',
)
assert response['status'] == '204'
bag = store.get(Bag('extra_private'))
assert bag.policy.owner == 'cdent'
assert bag.policy.read == ['cdent']
assert bag.policy.accept == ['NONE']
assert bag.policy.manage == ['cdent']
assert bag.policy.write == ['cdent']
assert bag.policy.create == ['cdent']
assert bag.policy.delete == ['cdent']
bag = store.get(Bag('extra_archive'))
assert bag.policy.owner == 'cdent'
assert bag.policy.read == ['cdent']
assert bag.policy.accept == ['NONE']
assert bag.policy.manage == ['cdent']
assert bag.policy.write == ['cdent']
assert bag.policy.create == ['cdent']
assert bag.policy.delete == ['cdent']
def test_store_bag():
bag = Bag('bag1')
bag.desc = 'bag 1 desc'
store.put(bag)
# these should be _description, not description etc
assert os.path.exists('store/bag1/description')
assert os.path.exists('store/bag1/policy')
loaded_bag = Bag('bag1')
loaded_bag = store.get(loaded_bag)
assert loaded_bag.desc == bag.desc
def test_where_it_goes():
store = Store(SAMPLE_CONFIG['server_store'][0],
SAMPLE_CONFIG['server_store'][1],
environ=ENVIRON)
bbag = Bag('bbag')
cbag = Bag('cbag')
store.put(bbag)
store.put(cbag)
assert os.path.exists('store1/bags/bbag/tiddlers')
assert os.path.exists('store2/bags/cbag/tiddlers')
assert not os.path.exists('store2/bags/bbag/tiddlers')
assert not os.path.exists('store1/bags/cbag/tiddlers')
def setup_module(module):
for dir in ('store', 'indexdir'):
try:
shutil.rmtree(dir)
except: # heavy!
pass
init(config)
store = get_store(config)
store.put(Bag('bagone'))
store.put(Bag('bagtwo'))
module.store = store
def tagged_tiddlers(environ, start_response):
store = environ['tiddlyweb.store']
bag_name = unicode(
urllib.unquote(environ['wsgiorg.routing_args'][1]['bag_name']),
'utf-8')
tag_name = unicode(
urllib.unquote(environ['wsgiorg.routing_args'][1]['tag_name']),
'utf-8')
bag = store.get(Bag(bag_name))
tmp_bag = Bag('tmpbag', tmpbag=True)
tmp_bag.add_tiddlers(
control.filter_tiddlers_from_bag(bag, 'select=tag:%s' % tag_name))
return send_tiddlers(environ, start_response, tmp_bag)
def test_delete():
bag = Bag('deleteme')
bag.desc = 'delete me please'
store.put(bag)
stored_bag = Bag('deleteme')
stored_bag = store.get(stored_bag)
assert stored_bag.desc == 'delete me please'
deleted_bag = Bag('deleteme')
store.delete(deleted_bag)
py.test.raises(NoBagError, 'store.get(deleted_bag)')
py.test.raises(NoBagError, 'store.delete(deleted_bag)')
def get_identities(environ, start_response):
"""
Get a list of the identities associated with the named user.
That named user must match the current user or the current
user must be an admin.
"""
store = environ['tiddlyweb.store']
username = get_route_value(environ, 'username')
usersign = environ['tiddlyweb.usersign']['name']
roles = environ['tiddlyweb.usersign']['roles']
if username != usersign and 'ADMIN' not in roles:
raise HTTP403('Bad user for action')
identities = []
try:
mapped_bag = store.get(Bag('MAPUSER'))
tiddlers = store.list_bag_tiddlers(mapped_bag)
matched_tiddlers = control.filter_tiddlers(
tiddlers, 'select=mapped_user:%s' % username, environ)
identities = [tiddler.title for tiddler in matched_tiddlers]
except NoBagError:
pass
start_response('200 OK',
[('Content-Type', 'application/json; charset=UTF-8')])
return [simplejson.dumps(identities)]
def test_two_bags():
bag_normal = Bag('normal')
store.put(bag_normal)
tiddler_normal = Tiddler('thing', 'normal')
tiddler_normal.text = 'hi'
store.put(tiddler_normal)
tiddlers = store.list_bag_tiddlers(bag_normal)
assert 'thing' in [tiddler.title for tiddler in tiddlers]
bag_special = Bag('Xnine')
tiddlers = store.list_bag_tiddlers(bag_special)
assert 'alpha' in [tiddler.title for tiddler in tiddlers]
tiddler = Tiddler('alpha', 'Xnine')
tiddler = store.get(tiddler)
assert tiddler.text == 'alpha'
def tiddler_as(self, tiddler):
"""
entry point for a single tiddler. Sets some variables
and passes the tiddler into list_tiddlers for turning
into HTML
"""
if 'tiddler' not in self.environ['tiddlyweb.recipe_template']:
self.environ['tiddlyweb.recipe_template'][
'tiddler'] = tiddler.title
if 'bag' not in self.environ['tiddlyweb.recipe_template']:
self.environ['tiddlyweb.recipe_template']['bag'] = tiddler.bag
if tiddler.recipe and 'recipe' not in self.environ[
'tiddlyweb.recipe_template']:
self.environ['tiddlyweb.recipe_template'][
'recipe'] = tiddler.recipe
bag = Bag('tmpbag', tmpbag=True)
bag.add_tiddler(tiddler)
self.plugin_name = self.set_plugin_name('single_tiddler')
if self.plugin_name not in self.environ['tiddlyweb.config'][
'tw_pages_serializers']:
content = self.pass_through_external_serializer(
self.plugin_name, tiddler)
return content
self.page_title = self.environ['tiddlyweb.config'][
'tw_pages_serializers'][self.plugin_name]['title'] or tiddler.title
return self.list_tiddlers(bag)
def recent_changes(environ, start_response):
"""
List recent changes for the named tank.
"""
tank_name = get_route_value(environ, 'bag_name')
store = environ['tiddlyweb.store']
usersign = environ['tiddlyweb.usersign']
days = environ['tiddlyweb.query'].get('d', [7])[0]
try:
bag = store.get(Bag(tank_name))
bag.policy.allows(usersign, 'read')
except NoBagError:
raise HTTP404('no tank found for %s' % tank_name)
tiddlers = (store.get(tiddler) for tiddler in filter_tiddlers(
store.list_bag_tiddlers(bag), 'select=modified:>%sd;sort=-modified' %
days, environ))
start_response('200 OK', [('Content-Type', 'text/html; charset=UTF-8'),
('Cache-Control', 'no-cache')])
return send_template(environ, CHANGES_TEMPLATE, {
'days': days,
'tiddlers': tiddlers,
'bag': bag,
})
def _look_for_tiddler_in_bag(tiddler, bag, filter_string,
environ, store, index_module):
"""
Look up the indicated tiddler in a bag, filtered by filter_string.
"""
if isinstance(bag, basestring):
bag = Bag(name=bag)
if store:
bag = store.get(bag)
def _query_index(bag):
"""
Try looking in an available index to see if the tiddler exists.
"""
kwords = {'id': '%s:%s' % (bag.name, tiddler.title)}
try:
tiddlers = index_module.index_query(environ, **kwords)
if list(tiddlers):
logging.debug(
'satisfied recipe bag query via filter index: %s:%s',
bag.name, tiddler.title)
return bag
except StoreError, exc:
raise FilterIndexRefused('unable to index_query: %s' % exc)
return None
def test_get_revision():
"""
Test we are able to retrieve a particular revision.
"""
bagone = Bag('bagone')
store.put(bagone)
tiddler = Tiddler('RevisionTiddler')
tiddler.text = 'how now 1'
tiddler.bag = u'bagone'
store.put(tiddler)
tiddler.text = 'how now 2'
store.put(tiddler)
tiddler.text = 'how now 3'
store.put(tiddler)
tiddler = Tiddler('RevisionTiddler', 'bagone')
tiddler = store.get(tiddler)
assert tiddler.text == 'how now 3'
assert tiddler.revision == 3
tiddler = Tiddler('RevisionTiddler', 'bagone')
tiddler.revision = 2
tiddler = store.get(tiddler)
assert tiddler.text == 'how now 2'
assert tiddler.revision == 2
revisions = store.list_tiddler_revisions(tiddler)
assert len(revisions) == 3
assert revisions[0] == 3
def setup_module(module):
try:
shutil.rmtree('indexdir')
shutil.rmtree('store')
except:
pass
app = load_app()
def app_fn():
return app
httplib2_intercept.install()
wsgi_intercept.add_wsgi_intercept('tankt.peermore.com', 8080, app_fn)
store = get_store(config)
test_bag = Bag('editable')
try:
store.delete(test_bag)
except StoreError:
pass
store.put(test_bag)
module.environ = {'tiddlyweb.store': store, 'tiddlyweb.config': config}
module.store = store
module.http = httplib2.Http()
module.csrf = None
def _make_space(environ, space_name):
"""
The details of creating the bags and recipes that make up a space.
"""
store = environ['tiddlyweb.store']
member = environ['tiddlyweb.usersign']['name']
# XXX stub out the clumsy way for now
# can make this much more declarative
space = Space(space_name)
for bag_name in space.list_bags():
bag = Bag(bag_name)
bag.policy = _make_policy(member)
if Space.bag_is_public(bag_name):
bag.policy.read = []
store.put(bag)
public_recipe = Recipe(space.public_recipe())
public_recipe.set_recipe(space.public_recipe_list())
private_recipe = Recipe(space.private_recipe())
private_recipe.set_recipe(space.private_recipe_list())
private_recipe.policy = _make_policy(member)
public_recipe.policy = _make_policy(member)
public_recipe.policy.read = []
store.put(public_recipe)
store.put(private_recipe)
def setup_module(module):
try:
shutil.rmtree('indexdir')
shutil.rmtree('store')
except:
pass
app = load_app()
def app_fn():
return app
requests_intercept.install()
wsgi_intercept.add_wsgi_intercept('tankt.peermore.com', 8080, app_fn)
store = get_store(config)
test_bag1 = Bag('newtank')
try:
store.delete(test_bag1)
except StoreError:
pass
test_bag1.policy.accept = ['NONE']
store.put(test_bag1)
module.environ = {'tiddlyweb.store': store, 'tiddlyweb.config': config}
module.store = store
module.cookie, module.csrf = establish_user_auth(
config, store, 'tankt.peermore.com:8080', 'tester')
def get_tiddlers(environ, start_response):
"""
Get the list of tiddlers produced by this
recipe.
"""
usersign = environ['tiddlyweb.usersign']
store = environ['tiddlyweb.store']
filters = environ['tiddlyweb.filters']
recipe = _determine_recipe(environ)
title = 'Tiddlers From Recipe %s' % recipe.name
title = environ['tiddlyweb.query'].get('title', [title])[0]
# check the recipe can be read
recipe.policy.allows(usersign, 'read')
# check the bags in the recipe can be read
try:
template = control.recipe_template(environ)
for bag_name, _ in recipe.get_recipe(template):
bag = Bag(bag_name)
bag = store.get(bag)
bag.policy.allows(usersign, 'read')
except NoBagError, exc:
raise HTTP404('recipe %s lists an unknown bag: %s' %
(recipe.name, exc))
def _make_bag(environ, bag_name=None):
bag_name = bag_name or "import-tmp-%s" % str(uuid())
store = environ['tiddlyweb.store']
bag = Bag(bag_name)
_set_restricted_policy(environ, bag)
store.put(bag)
return bag
