def test_boolean():
"""
We expect a default AND but can do OR.
"""
store.put(Bag('mybag'))
tiddlera = Tiddler('a', 'mybag')
tiddlera.tags = ['one', '@two']
store.put(tiddlera)
tiddlerb = Tiddler('b', 'mybag')
tiddlerb.tags = ['@two', 'three']
store.put(tiddlerb)
tiddlerc = Tiddler('c', 'mybag')
tiddlerc.tags = ['three', 'four']
store.put(tiddlerc)
tiddlers = list(search(config, 'tags:one'))
assert len(tiddlers) == 1
tiddlers = list(search(config, 'tags:@two'))
assert len(tiddlers) == 2
tiddlers = list(search(config, 'tags:one tags:@two'))
assert len(tiddlers) == 1
tiddlers = list(search(config, 'tags:one tags:four'))
assert len(tiddlers) == 0
tiddlers = list(search(config, 'tags:one OR tags:four'))
assert len(tiddlers) == 2
def test_modified():
"""
Note the multiple store.put in here are to create
additional revisions to make sure that joins are
sufficiently limited.
"""
tiddler = Tiddler(u'GettingStarted', u'fnd_public')
tiddler.modifier = u'fnd'
store.put(tiddler)
tiddlers = list(store.search(u'modifier:fnd'))
assert len(tiddlers) == 1
tiddler = Tiddler(u'GettingStarted', u'fnd_public')
tiddler.tags = [u'monkey', u'cow', u'food']
tiddler.modifier = u'cdent'
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
tiddlers = list(store.search(u'modifier:fnd'))
assert len(tiddlers) == 0
tiddler = Tiddler(u'GettingFancy', u'fnd_public')
tiddler.tags = [u'cow', u'food']
tiddler.modifier = u'fnd'
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
tiddlers = list(store.search(u'modifier:fnd OR modifier:cdent'))
assert len(tiddlers) == 2
tiddlers = list(store.search(u'modifier:fnd NOT modifier:cdent'))
assert len(tiddlers) == 1
tiddlers = list(
store.search(
u'modifier:fnd NOT (modifier:cdent OR title:GettingStarted)'))
assert len(tiddlers) == 1
tiddlers = list(store.search(u'modifier:fnd AND modified:20*'))
assert len(tiddlers) == 1
def test_or_tags():
tiddler = Tiddler("tagone", "fnd_public")
tiddler.text = "hi @onething hello"
tiddler.tags = ["one", "three", "five"]
store.put(tiddler)
tiddler = Tiddler("tagtwo", "fnd_public")
tiddler.text = "hi @twothing hello"
tiddler.tags = ["two", "four", "six"]
store.put(tiddler)
tiddlers = list(store.search(u"@twothing OR tag:one"))
assert len(tiddlers) == 2
def test_or_tags():
tiddler = Tiddler(u'tagone', u'fnd_public')
tiddler.text = u'hi @onething hello'
tiddler.tags = [u'one', u'three', u'five']
store.put(tiddler)
tiddler = Tiddler(u'tagtwo', u'fnd_public')
tiddler.text = u'hi @twothing hello'
tiddler.tags = [u'two', u'four', u'six']
store.put(tiddler)
tiddlers = list(store.search(u'@twothing OR tag:one'))
assert len(tiddlers) == 2
def test_or_tags():
tiddler = Tiddler(u'tagone', u'fnd_public')
tiddler.text = 'hi @onething hello'
tiddler.tags = ['one','three', 'five']
store.put(tiddler)
tiddler = Tiddler(u'tagtwo', u'fnd_public')
tiddler.text = 'hi @twothing hello'
tiddler.tags = ['two', 'four', 'six']
store.put(tiddler)
tiddlers = list(store.search(u'@twothing OR tag:one'))
assert len(tiddlers) == 2
def test_modified():
"""
Note the multiple store.put in here are to create
additional revisions to make sure that joins are
sufficiently limited.
"""
tiddler = Tiddler("GettingStarted", "fnd_public")
tiddler.modifier = u"fnd"
store.put(tiddler)
tiddlers = list(store.search(u"modifier:fnd"))
assert len(tiddlers) == 1
tiddler = Tiddler("GettingStarted", "fnd_public")
tiddler.tags = [u"monkey", u"cow", u"food"]
tiddler.modifier = u"cdent"
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
tiddlers = list(store.search(u"modifier:fnd"))
assert len(tiddlers) == 0
tiddler = Tiddler("GettingFancy", "fnd_public")
tiddler.tags = [u"cow", u"food"]
tiddler.modifier = u"fnd"
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
tiddlers = list(store.search(u"modifier:fnd OR modifier:cdent"))
assert len(tiddlers) == 2
tiddlers = list(store.search(u"modifier:fnd NOT modifier:cdent"))
assert len(tiddlers) == 1
tiddlers = list(store.search(u"modifier:fnd NOT (modifier:cdent OR title:GettingStarted)"))
assert len(tiddlers) == 1
tiddlers = list(store.search(u"modifier:fnd AND modified:20*"))
assert len(tiddlers) == 1
def test_modified():
"""
Note the multiple store.put in here are to create
additional revisions to make sure that joins are
sufficiently limited.
"""
tiddler = Tiddler(u'GettingStarted', u'fnd_public')
tiddler.modifier = u'fnd';
store.put(tiddler)
tiddlers = list(store.search(u'modifier:fnd'))
assert len(tiddlers) == 1
tiddler = Tiddler(u'GettingStarted', u'fnd_public')
tiddler.tags = [u'monkey', u'cow', u'food']
tiddler.modifier = u'cdent';
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
tiddlers = list(store.search(u'modifier:fnd'))
assert len(tiddlers) == 0
tiddler = Tiddler(u'GettingFancy', u'fnd_public')
tiddler.tags = [u'cow', u'food']
tiddler.modifier = u'fnd';
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
store.put(tiddler)
tiddlers = list(store.search(u'modifier:fnd OR modifier:cdent'))
assert len(tiddlers) == 2
tiddlers = list(store.search(u'modifier:fnd NOT modifier:cdent'))
assert len(tiddlers) == 1
tiddlers = list(store.search(u'modifier:fnd NOT (modifier:cdent OR title:GettingStarted)'))
assert len(tiddlers) == 1
tiddlers = list(store.search(u'modifier:fnd AND modified:20*'))
assert len(tiddlers) == 1
def test_post_existing():
"""
testing posting an existing tiddler to check that it is overwritten
"""
#setup
setup(store)
tiddler = Tiddler('i exist','jon_private')
tiddler.fields['geo.lat'] = '20'
tiddler.fields['geo.long'] = '2'
tiddler.text = 'data'
tiddler.tags = ['a', 'b']
store.put(tiddler)
#run
mailer.handle_email({
'to': '*****@*****.**',
'from': '*****@*****.**',
'subject': 'i exist',
'body': 'wipeout'
})
#verify
tiddler = store.get(Tiddler('i exist', 'jon_private'))
assert tiddler.text == 'wipeout'
assert tiddler.fields.get('geo.lat') == None
def test_revisions_deletions():
tiddler = Tiddler('tone', 'pone')
tiddler.text = u'revision1'
tiddler.tags = [u'1', u'2']
STORE.put(tiddler)
tiddler.text = u'revision2'
tiddler.tags = [u'3', u'4']
STORE.put(tiddler)
revisions = STORE.list_tiddler_revisions(tiddler)
assert len(revisions) == 2
STORE.delete(tiddler)
py.test.raises(NoTiddlerError, 'STORE.list_tiddler_revisions(tiddler)')
def url(args):
"""Add a URL via tiddlywebplugins.URLs. Redirect is optional. [--redirect] <selector_path> <destination_url>"""
if 2 != len(args) != 3:
print >> sys.stderr, ('you must include both the path you want to use (selector path) and the destination url')
store = get_store(config)
if args[0] == '--redirect':
redirect = args.pop(0).lstrip('-')
else:
redirect = None
selector_path = args[0]
destination_url = args[1]
tiddler = Tiddler(selector_path)
tiddler.bag = config['url_bag']
tiddler.text = destination_url
if redirect:
tiddler.tags = [redirect]
if validate_url(tiddler):
store.put(tiddler)
return True
def test_cascade():
bag = Bag(u'holder')
store.put(bag)
tiddler = Tiddler(u'one', u'holder')
tiddler.text = u'text'
tiddler.tags = [u'tag']
tiddler.fields = {u'fieldone': u'valueone'}
store.put(tiddler)
def count_em(count, message):
text_count = store.storage.session.query(sText).count()
tag_count = store.storage.session.query(sTag).count()
tiddler_count = store.storage.session.query(sTiddler).count()
revision_count = store.storage.session.query(sRevision).count()
field_count = store.storage.session.query(sField).count()
store.storage.session.commit()
message = ('%s, but got: text: %s, tag: %s, tiddler: %s, '
'revision: %s, field: %s') % (message, text_count,
tag_count, tiddler_count,
revision_count, field_count)
assert (text_count == tag_count == tiddler_count == revision_count ==
field_count == count), message
count_em(1, '1 row for the tiddler everywhere')
store.delete(tiddler)
count_em(0, '0 rows for the tiddler everywhere')
def test_in_a_recipe():
from tiddlyweb.config import config
store = get_store(config)
bag = Bag('hi')
store.put(bag)
tiddler = Tiddler('thing1', 'hi')
tiddler.tags = ['research']
store.put(tiddler)
tiddler = Tiddler('thing2', 'hi')
store.put(tiddler)
recipe1 = Recipe('oi')
recipe1.set_recipe([('hi', 'mselect=tag:research')])
recipe1.store = store
recipe2 = Recipe('coi')
recipe2.set_recipe([('hi', 'select=tag:research')])
recipe2.store = store
recipe3 = Recipe('boi')
recipe3.set_recipe([('hi', '')])
recipe3.store = store
environ = {'tiddlyweb.store': store}
tiddlers = list(control.get_tiddlers_from_recipe(recipe1, environ))
assert len(tiddlers) == 1
tiddlers = list(control.get_tiddlers_from_recipe(recipe2, environ))
assert len(tiddlers) == 1
tiddlers = list(control.get_tiddlers_from_recipe(recipe3, environ))
assert len(tiddlers) == 2
def test_view():
"""
test a request for viewing a single tiddler
"""
#setup
setup(store)
tiddler = Tiddler('GettingStarted', 'jon_private')
tiddler.text = 'the cat jumped over the moon'
tiddler.tags = ['hello', 'world']
store.put(tiddler)
#run
email = mailer.handle_email({
'to': '*****@*****.**',
'from': '*****@*****.**',
'subject': 'GettingStarted',
'body': ''
})
#verify
assert email == {
'to': '*****@*****.**',
'from': '*****@*****.**',
'subject': 'GettingStarted',
'body': 'the cat jumped over the moon'
}
def test_tiddler_full_create():
"""
Confirm we can populate a tiddler at create time.
"""
tiddler = Tiddler('test tiddler')
tiddler.modifier = '*****@*****.**'
tiddler.text = test_tiddler_text
tiddler.tags = ['foo', 'bar']
tiddler.bag = u'bagone'
assert type(tiddler) == Tiddler, \
'Tiddler returns a Tiddler'
assert tiddler.title == 'test tiddler', \
'tiddler title should be test tiddler, got %s' \
% tiddler.title
assert tiddler.modifier == '*****@*****.**', \
'tiddler modifier should [email protected], got %s' \
% tiddler.modifier
assert tiddler.text == test_tiddler_text, \
'tiddler content is correct'
assert tiddler.tags == ['foo', 'bar'], \
'tiddler tags are correct'
assert tiddler.bag == 'bagone', \
'tiddler has a bag of bagone'
assert tiddler.revision is None, \
'tiddler revision is None'
assert tiddler.creator == '*****@*****.**'
def test_html_attribute_escape_with_bag():
tiddler = Tiddler('escape "double" quotes in tiddler field values')
tiddler.bag = 'foo "bar" baz'
tiddler.modifier = 'Chris "sensei" Dent'
tiddler.tags = ["foo", 'xxx "yyy" zzz']
tiddler.fields["custom"] = u"""lorem 'ipsum' dolor "sit" amet"""
tiddler.text = ''
serializer = Serializer('tiddlywebwiki.serialization', environ)
serializer.object = tiddler
string = serializer.to_string()
assert ('title="escape "double" quotes in tiddler field values"'
in string)
assert ('server.title="escape "double" quotes in tiddler '
'field values"' in string)
assert 'bag="foo "bar" baz"' in string
assert 'server.workspace="bags/foo "bar" baz"' in string
assert 'modifier="Chris "sensei" Dent"' in string
assert 'creator="Chris "sensei" Dent"' in string
assert 'tags="foo [[xxx "yyy" zzz]]"' in string
assert '''custom="lorem 'ipsum' dolor "sit" amet"''' in string
# single tiddler's browse link is that tiddler in its bag
assert ('you may still <a href="/bags/foo%20%22bar%22%20baz/tiddlers/'
'escape%20%22double%22%20quotes%20in%20tiddler%20field%20'
'values">browse' in string)
def test_for_tags():
tiddler1 = Tiddler('one', 'bagone')
tiddler2 = Tiddler('two', 'bagtwo')
tiddler1.tags = ['alpha', 'beta']
tiddler2.tags = ['alpha', 'gamma']
store.put(tiddler1)
store.put(tiddler2)
tags = get_indexed_tags(config, None)
assert len(tags) == 3
assert sorted(tags) == ['alpha', 'beta', 'gamma']
tags = get_indexed_tags(config, 'bag:"bagone"')
assert len(tags) == 2
assert sorted(tags) == ['alpha', 'beta']
def test_simple():
bag = Bag('MAGICUSER')
store.put(bag)
extractor = Extractor()
userinfo = {'name': 'cdent', 'roles': ['HELLO']}
more_info = extractor.extract_more_info(environ, userinfo)
assert 'modifier' in more_info
assert 'name' in more_info
assert 'roles' in more_info
assert 'tags' in more_info
assert 'fields' in more_info
assert 'modified' in more_info
assert more_info['tags'] == []
assert more_info['fields'] == {}
assert more_info['roles'] == ['HELLO']
tiddler = Tiddler('cdent', 'MAGICUSER')
tiddler.fields['roles'] = "GOODBYE CHRISTMAS EASTER ADMIN"
tiddler.tags = ['monkey', 'hello', 'barney']
tiddler.fields['spaces'] = "one two three"
store.put(tiddler)
more_info = extractor.extract_more_info(environ, userinfo)
assert more_info['tags'] == ['monkey', 'hello', 'barney']
assert len(more_info['roles']) == 5
for role in ['HELLO', 'GOODBYE', 'CHRISTMAS', 'EASTER', 'ADMIN']:
assert role in more_info['roles']
assert more_info['fields']['spaces'] == 'one two three'
def test_simple_magic():
bag = Bag('MAGICUSER')
store.put(bag)
extractor = Extractor()
userinfo = {'name': 'cdent', 'roles': ['HELLO']}
more_info = extractor.extract_more_info(environ, userinfo)
assert 'modifier' in more_info
assert 'name' in more_info
assert 'roles' in more_info
assert 'tags' in more_info
assert 'fields' in more_info
assert 'modified' in more_info
assert more_info['tags'] == []
assert more_info['fields'] == {}
assert more_info['roles'] == ['HELLO']
tiddler = Tiddler('cdent', 'MAGICUSER')
tiddler.fields['roles'] = "GOODBYE CHRISTMAS EASTER ADMIN"
tiddler.tags = ['monkey', 'hello', 'barney']
tiddler.fields['spaces'] = "one two three"
store.put(tiddler)
more_info = extractor.extract_more_info(environ, userinfo)
assert sorted(more_info['tags']) == [u'barney', u'hello', u'monkey']
assert len(more_info['roles']) == 5
for role in ['HELLO', 'GOODBYE', 'CHRISTMAS', 'EASTER', 'ADMIN']:
assert role in more_info['roles']
assert more_info['fields']['spaces'] == 'one two three'
def test_tiddler_full_create():
"""
Confirm we can populate a tiddler at create time.
"""
tiddler = Tiddler('test tiddler')
tiddler.modifier = '*****@*****.**'
tiddler.text = test_tiddler_text
tiddler.tags = ['foo', 'bar']
tiddler.bag = u'bagone'
assert type(tiddler) == Tiddler, \
'Tiddler returns a Tiddler'
assert tiddler.title == 'test tiddler', \
'tiddler title should be test tiddler, got %s' \
% tiddler.title
assert tiddler.modifier == '*****@*****.**', \
'tiddler modifier should [email protected], got %s' \
% tiddler.modifier
assert tiddler.text == test_tiddler_text, \
'tiddler content is correct'
assert tiddler.tags == ['foo', 'bar'], \
'tiddler tags are correct'
assert tiddler.bag == 'bagone', \
'tiddler has a bag of bagone'
assert tiddler.revision is None, \
'tiddler revision is None'
assert tiddler.creator == '*****@*****.**'
def test_revisions_deletions():
tiddler = Tiddler("tone", "pone")
tiddler.text = u"revision1"
tiddler.tags = [u"1", u"2"]
store.put(tiddler)
tiddler.text = u"revision2"
tiddler.tags = [u"3", u"4"]
store.put(tiddler)
revisions = store.list_tiddler_revisions(tiddler)
assert len(revisions) == 2
store.delete(tiddler)
py.test.raises(NoTiddlerError, "store.list_tiddler_revisions(tiddler)")
def test_tiddler_put():
store_root = os.path.join(TMPDIR, "test_store")
bag = Bag("alpha")
tiddler = Tiddler("Foo", bag.name)
tiddler.text = "lorem ipsum\ndolor sit amet"
tiddler.tags = ["foo", "bar"]
STORE.put(bag)
bag_dir = os.path.join(store_root, "bags", "alpha")
assert os.path.isdir(bag_dir)
assert os.path.isdir(os.path.join(bag_dir, "tiddlers"))
STORE.put(tiddler)
tiddler_file = os.path.join(bag_dir, "tiddlers", "Foo")
assert os.path.isfile(tiddler_file)
assert len(tiddler.revision) == 40
with open(tiddler_file) as fh:
contents = fh.read()
assert "tags: foo bar" in contents
assert tiddler.text in contents
info = run("git", "log", "-n1", "--format=%ae %ce: %s", cwd=store_root)
assert info.strip() == "[email protected] [email protected]: tiddler put"
def setup_testdata():
testdata = [
{"title":u"Whiskers","tags":["I wRiTe lIke A fIvE yEaR oLd","Kitty","pet","lolcat"],"fields":{"read":"no","badfield":"z"}},
{"title":u"Fred","tags":["dog","pet"],"fields":{"badfield":"xt"}},
{"title":u"Chris","tags":["cat","animal","bogof"],"fields":{"badfield":"ks"}},
{"title":u"Martin","tags":["fish","lion"],"fields":{"badfield":"zs"}},
{"title":u"Jerm","tags":["monkey"],"fields":{"badfield":"z"}},
{"title":u"Paul","tags":["dinosaurs rule","tiger"],"fields":{"badfield":"z"}},
{"title":u"Ben","tags":["cAt","i love my cat"],"fields":{"badfield":"z"}},
{"title":u"Andrew","tags":["Pet","Animal","kitty","ToysRUs"],"fields":{"badfield":"z","foo":"yes"}}
]
tiddlers = []
for tid in testdata:
tiddler = Tiddler(tid["title"],"tmp")
tiddler.fields = tid["fields"]
tiddler.tags = tid["tags"]
tiddlers.append(tiddler)
bag = Bag("tmp")
try:
store.delete(bag)#delete any existing one
except NoBagError:
pass
store.put(bag)
for tiddler in tiddlers:
store.put(tiddler)
def test_revisions_deletions():
tiddler = Tiddler(u'tone', u'pone')
tiddler.text = u'revision1'
tiddler.tags = [u'1', u'2']
store.put(tiddler)
tiddler.text = u'revision2'
tiddler.tags = [u'3', u'4']
store.put(tiddler)
revisions = store.list_tiddler_revisions(tiddler)
assert len(revisions) == 2
store.delete(tiddler)
py.test.raises(NoTiddlerError, 'store.list_tiddler_revisions(tiddler)')
def test_revision_get():
bag = Bag('alpha')
STORE.put(bag)
# create a bunch of revisions
tiddler_data = [
{ 'text': 'hello world', 'tags': ['foo'] },
{ 'text': 'lorem ipsum', 'tags': ['foo', 'bar'] },
{ 'text': 'lorem ipsum\ndolor sit amet', 'tags': [] }
]
for tid in tiddler_data:
tiddler = Tiddler('Foo', bag.name)
tiddler.text = tid['text']
tiddler.tags = tid['tags']
STORE.put(tiddler)
tid['revision'] = tiddler.revision
tiddler = Tiddler('Foo', bag.name)
tiddler.revision = None
tiddler = STORE.get(tiddler)
assert tiddler.text == 'lorem ipsum\ndolor sit amet'
assert len(tiddler.tags) == 0
for i, tid in enumerate(tiddler_data):
tiddler = Tiddler('Foo', bag.name)
tiddler.revision = tid['revision']
tiddler = STORE.get(tiddler)
assert tiddler.text == tid['text']
assert len(tiddler.revision) == 10
assert len(tiddler.tags) == len(tid['tags'])
tiddler = Tiddler('Foo', bag.name)
tiddler.revision = 'N/A'
with raises(NoTiddlerError):
STORE.get(tiddler)
def test_emoji_title():
"""
We expect this to fail because we're using a) old mysql
b) without the utf8mb4 encoding type.
See: https://github.com/TiddlySpace/tiddlyspace/issues/1033
The fix is to use mysql 5.5 or beyond.
"""
# emoji smiley of some sort
title = '\xF0\x9F\x98\x97'.decode('utf-8')
store.put(Bag(title))
tiddler = Tiddler(title, title)
tiddler.text = u'some stuff and zomg %s' % title
tiddler.tags = [title]
tiddler.fields[title] = title
store.put(tiddler)
tiddler2 = store.get(Tiddler(title, title))
assert tiddler2.title == title
assert tiddler2.text == tiddler.text
assert tiddler2.tags == tiddler.tags
assert tiddler2.tags[0] == title
assert tiddler2.fields[title] == tiddler.fields[title]
assert tiddler2.fields[title] == title
def test_revisions_deletions():
tiddler = Tiddler(u'tone', u'pone')
tiddler.text = u'revision1'
tiddler.tags = [u'1', u'2']
store.put(tiddler)
tiddler.text = u'revision2'
tiddler.tags = [u'3', u'4']
store.put(tiddler)
revisions = store.list_tiddler_revisions(tiddler)
assert len(revisions) == 2
store.delete(tiddler)
py.test.raises(NoTiddlerError, 'store.list_tiddler_revisions(tiddler)')
def test_cascade():
bag = Bag(u'holder')
store.put(bag)
tiddler = Tiddler(u'one', u'holder')
tiddler.text = u'text'
tiddler.tags = [u'tag']
tiddler.fields = {u'fieldone': u'valueone'}
store.put(tiddler)
def count_em(count, message):
text_count = store.storage.session.query(sText).count()
tag_count = store.storage.session.query(sTag).count()
tiddler_count = store.storage.session.query(sTiddler).count()
revision_count = store.storage.session.query(sRevision).count()
field_count = store.storage.session.query(sField).count()
store.storage.session.commit()
message = ('%s, but got: text: %s, tag: %s, tiddler: %s, '
'revision: %s, field: %s') % (message, text_count, tag_count,
tiddler_count, revision_count, field_count)
assert (text_count == tag_count == tiddler_count
== revision_count == field_count == count), message
count_em(1, '1 row for the tiddler everywhere')
store.delete(tiddler)
count_em(0, '0 rows for the tiddler everywhere')
def handle_tiddler_div(bagname, tiddler_div, store):
"""
Create a new Tiddler from a tiddler div, in beautifulsoup
form.
"""
new_tiddler = Tiddler(tiddler_div['title'], bag=bagname)
try:
new_tiddler.text = _html_decode(tiddler_div.find('pre').contents[0])
except IndexError:
# there are no contents in the tiddler
new_tiddler.text = ''
for attr, value in tiddler_div.attrs:
data = tiddler_div.get(attr, None)
if data and attr != 'tags':
if attr in (['modifier', 'created', 'modified']):
new_tiddler.__setattr__(attr, data)
else:
new_tiddler.fields[attr] = data
new_tiddler.tags = _tag_string_to_list(tiddler_div.get('tags', ''))
try:
store.put(new_tiddler)
except OSError, exc:
# This tiddler has a name that we can't yet write to the
# store. For now we just state the error and carry on.
import sys
print >> sys.stderr, 'Unable to write %s: %s' % (new_tiddler.title, exc)
def process_email(self,fromAddress,toAddress,subject,body):
title,tags = self.get_tags_and_title(subject)
tiddler = Tiddler(title)
tiddler.tags = tags
tiddler.modifier = fromAddress
tiddler.text =body
return tiddler
def test_tags():
tid = Tiddler("foo","bar")
tid.tags = ['ab', 'cd','ef gh']
env = {}
out = macros.tags(WikiContext(tid,env))
assert '</li>' in out
assert 'ab</a></li>' in out
assert 'cd</a></li>' in out
assert '</ul>' in out
def test_at_tags():
tiddler = Tiddler(u'tagat', u'fnd_public')
tiddler.text = u'new stuff to not mess'
tiddler.tags = [u'one', u'three', u'five', u'@cdent']
store.put(tiddler)
tiddlers = list(store.search(u'tag:@cdent'))
assert len(tiddlers) == 1
def test_at_tags():
tiddler = Tiddler("tagat", "fnd_public")
tiddler.text = "new stuff to not mess"
tiddler.tags = ["one", "three", "five", "@cdent"]
store.put(tiddler)
tiddlers = list(store.search(u"tag:@cdent"))
assert len(tiddlers) == 1
def test_tags():
tid = Tiddler("foo", "bar")
tid.tags = ['ab', 'cd', 'ef gh']
env = {}
out = macros.tags(WikiContext(tid, env))
assert '</li>' in out
assert 'ab</a></li>' in out
assert 'cd</a></li>' in out
assert '</ul>' in out
def _manage_update_routes(environ, gym):
store = environ['tiddlyweb.store']
query = environ['tiddlyweb.query']
existing_titles = query.get('title', [])
count = len(existing_titles)
index = 0
delete = query.get('delete', [])
lead_route = query.get(LEAD_FIELD, [])
while index < count:
title = existing_titles[index]
tiddler = Tiddler(title, '%s_climbs' % gym)
try:
tiddler = store.get(tiddler)
if title in delete:
original_bag = tiddler.bag
tiddler.bag = '%s_archive' % gym
store.put(tiddler)
tiddler.bag = original_bag
store.delete(tiddler)
index += 1
continue
except StoreError:
pass
changed = False
for key in ROUTE_FIELDS:
value = query.get(key, [''])[index]
if tiddler.fields[key] != value:
tiddler.fields[key] = value
changed = True
if LEAD_FIELD in tiddler.fields and title not in lead_route:
del tiddler.fields[LEAD_FIELD]
changed = True
elif title in lead_route and LEAD_FIELD not in tiddler.fields:
tiddler.fields[LEAD_FIELD] = '1'
changed = True
if changed:
store.put(tiddler)
index += 1
try:
title = query.get('title', [])[index]
except IndexError:
title = str(uuid4())
tiddler = Tiddler(title, '%s_climbs' % gym)
new_route = False
if 'new_one' in lead_route:
tiddler.fields[LEAD_FIELD] = '1'
for key in ROUTE_FIELDS:
value = query.get(key, [''])[index]
if value == '':
continue
new_route = True
tiddler.fields[key] = value
tiddler.tags = ['route']
if new_route:
store.put(tiddler)
raise HTTP303(server_base_url(environ) + '/manager/%s' % gym)
def test_at_tags():
tiddler = Tiddler(u'tagat', u'fnd_public')
tiddler.text = 'new stuff to not mess'
tiddler.tags = ['one','three', 'five', '@cdent']
store.put(tiddler)
tiddlers = list(store.search(u'tag:@cdent'))
assert len(tiddlers) == 1
def test_sidebar_global():
store.put(Bag('cdent'))
tiddler = Tiddler('%s' % uuid4(), 'cdent')
tiddler.tags = ['climb']
tiddler.text = 'sweet'
store.put(tiddler)
tiddlers = list(get_sidebar(environ))
assert len(tiddlers) == 5
def test_paren_title():
tiddler = Tiddler(u'(i)', u'fnd_public')
tiddler.text = u'hi @onething hello'
tiddler.tags = [u'one', u'three', u'five']
store.put(tiddler)
tiddlers = list(store.search(u'title:(i)'))
assert len(tiddlers) == 1
assert tiddlers[0].title == '(i)'
def test_search_quoted_phrase():
bag = Bag('bag1')
store.put(bag)
tiddler1 = Tiddler('tiddler1', 'bag1')
tiddler1.text = 'There are five monkeys in this house'
tiddler1.tags = ['oh', 'hai', 'you', 'five chimps']
store.put(tiddler1)
tiddlers = list(search(config, '"five monkeys"'))
assert len(tiddlers) == 1
def test_paren_title():
tiddler = Tiddler(u'(i)', u'fnd_public')
tiddler.text = 'hi @onething hello'
tiddler.tags = ['one','three', 'five']
store.put(tiddler)
tiddlers = list(store.search(u'title:(i)'))
assert len(tiddlers) == 1
assert tiddlers[0].title == '(i)'
def test_validate_tiddler():
tiddler = Tiddler('foobar', 'barney')
tiddler.text = 'I am a dinosaur'
tiddler.tags = ['tag1', 'tag2']
py.test.raises(InvalidTiddlerError, 'validate_tiddler(tiddler)')
tiddler.text = 'I am a dinosaur who likes to foobar'
validate_tiddler(tiddler)
assert 'FOOBAR' in tiddler.text
def test_simple_store():
bag = Bag(u'bag1')
store.put(bag)
tiddler = Tiddler(u'tiddler1', u'bag1')
tiddler.text = u'oh hello i chrisdent have nothing to say here you know'
tiddler.tags = [u'apple', u'orange', u'pear']
tiddler.fields[u'house'] = u'cottage'
store.put(tiddler)
retrieved = Tiddler(u'tiddler1', u'bag1')
retrieved = store.get(retrieved)
assert retrieved.text == tiddler.text
def create_tiddler(store, bag, numeral):
tiddler = Tiddler('tiddler%s' % numeral)
tiddler.bag = bag.name
tiddler.text = u'i am tiddler %s' % numeral
tags = [u'basic tag']
if not numeral % 2:
tags.append(u'tagtwo')
if not numeral % 3:
tags.append(u'tagthree')
if not numeral % 4:
tags.append(u'tagfour')
tiddler.tags = tags
if tiddler.title == 'tiddler8':
tiddler.modified = '200805230303'
store.put(tiddler)
def test_html_attribute_escape():
tiddler = Tiddler(
'escape "double" quotes & & in <tiddler> field values')
tiddler.bag = u'foo "bar" baz'
tiddler.modifier = 'Chris "sensei" Dent'
tiddler.tags = ["foo", 'xxx "yyy" zzz']
tiddler.fields["custom"] = u"""lorem 'ipsum' dolor "sit" amet"""
tiddler.text = ''
serializer = Serializer('html')
serializer.object = tiddler
string = serializer.to_string()
assert r'''title="escape "double" quotes & &amp; in <tiddler> field values"''' in string
assert r'''modifier="Chris "sensei" Dent"''' in string
assert r'''tags="foo [[xxx "yyy" zzz]]"''' in string
assert r'''custom="lorem 'ipsum' dolor "sit" amet"''' in string
def test_multi_same_tag_tiddler():
bag = Bag(u'holder')
store.put(bag)
tiddler = Tiddler(u'me', u'holder')
tiddler.text = u'hi'
tiddler.tags = [u'foo']
store.put(tiddler)
tiddler2 = Tiddler(u'me', u'holder')
tiddler2 = store.get(tiddler2)
tiddler2.tags.append(u'bar')
tiddler2.tags.append(u'bar')
store.put(tiddler2)
tiddler3 = store.get(Tiddler(u'me', u'holder'))
assert sorted(tiddler3.tags) == ['bar', 'foo']
def test_tiddler_fields_ignore_server():
bag = Bag('bag0')
store.put(bag)
tiddler = Tiddler('server\nimpostor', bag='bag0')
tiddler.tags = [u'foo\nbar']
tiddler.fields = {
u'field1': u'value1\nafterlinefeed',
u'server.host': u'value1',
u'server.type': u'value2'
}
store.put(tiddler)
tiddler_second = Tiddler('server\nimpostor', bag='bag0')
tiddler_second = store.get(tiddler_second)
assert tiddler_second.fields['field1'] == 'value1\nafterlinefeed'
assert 'server.host' not in tiddler_second.fields.keys()
assert 'server.type' not in tiddler_second.fields.keys()
def test_put_get_tiddler():
bag = Bag(u'test1')
store.put(bag)
for i in xrange(5):
tiddler = Tiddler(u'tid1', u'test1')
tiddler.text = u'hello'
tiddler.tags = [u'five', u'six']
tiddler.fields[u'radar'] = u'green'
store.put(tiddler)
read_tiddler = Tiddler('tid1', 'test1')
read_tiddler = store.get(read_tiddler)
assert read_tiddler.title == 'tid1'
assert read_tiddler.fields['radar'] == 'green'
def setup_module(module):
make_test_env(module)
httplib2_intercept.install()
wsgi_intercept.add_wsgi_intercept('thing.0.0.0.0', 8080, app_fn)
make_fake_space(store, 'thing')
tiddler = Tiddler('ServerSettings', 'thing_public')
tiddler.text = 'htmltemplate: clean1\n'
store.put(tiddler)
tiddler = Tiddler('TestMe', 'thing_public')
tiddler.text = '# Hi\n\n# one\n# two'
tiddler.tags = ['alpha', 'beta', '12th monkey']
store.put(tiddler)
module.tiddler_modified = tiddler.modified
module.http = httplib2.Http()
def _make_tiddler(environ, user):
"""
Slice and dice the input to make it into a tiddler.
"""
posted_data = environ['tiddlyweb.query']
charset = posted_data.get('charset', ['UTF-8'])[0]
url = posted_data.get('url', [''])[0]
title = posted_data.get('title', [''])[0]
title = unicode(title, charset, 'replace')
snip = posted_data.get('snip', [''])[0]
snip = unicode(snip, charset, 'replace')
tiddler_title = title.replace('.', '_')
tiddler_text_title = title.replace('|', ' ')
tiddler = Tiddler(tiddler_title)
tiddler.tags = [u'twoted']
tiddler.modifier = user
tiddler.text = '[[%s|%s]]\n\n%s' % (tiddler_text_title, url, snip)
return tiddler
def test_emoji_title():
# emoji smiley of some sort
title = '\xF0\x9F\x98\x97'.decode('utf-8')
store.put(Bag(title))
tiddler = Tiddler(title, title)
tiddler.text = u'some stuff and zomg %s' % title
tiddler.tags = [title]
tiddler.fields[title] = title
store.put(tiddler)
tiddler2 = store.get(Tiddler(title, title))
assert tiddler2.title == title
assert tiddler2.text == tiddler.text
assert tiddler2.tags == tiddler.tags
assert tiddler2.tags[0] == title
assert tiddler2.fields[title] == tiddler.fields[title]
assert tiddler2.fields[title] == title
def _get_tiddler_from_div(node):
"""
Create a Tiddler from an HTML div element.
"""
tiddler = Tiddler(node.getAttribute('title'))
tiddler.text = _html_decode(_get_text(node.getElementsByTagName('pre')))
for attr, value in node.attributes.items():
data = value
if data and attr != 'tags':
if attr in (['creator', 'modifier', 'created', 'modified']):
tiddler.__setattr__(attr, data)
elif (attr not in ['title', 'changecount']
and not attr.startswith('server.')):
tiddler.fields[attr] = data
if not node.attributes.get('modified', None) and tiddler.created:
tiddler.modified = tiddler.created
tiddler.tags = string_to_tags_list(node.getAttribute('tags'))
return tiddler
def test_html_attribute_escape_with_bag():
tiddler = Tiddler('escape "double" quotes in tiddler field values')
tiddler.bag = 'foo "bar" baz'
tiddler.modifier = 'Chris "sensei" Dent'
tiddler.tags = ["foo", 'xxx "yyy" zzz']
tiddler.fields["custom"] = u"""lorem 'ipsum' dolor "sit" amet"""
tiddler.text = ''
serializer = Serializer('tiddlywebwiki.serialization', environ)
serializer.object = tiddler
string = serializer.to_string()
assert r'''title="escape "double" quotes in tiddler field values"''' in string
assert r'''server.title="escape "double" quotes in tiddler field values"''' in string
assert r'''bag="foo "bar" baz"''' in string
assert r'''server.workspace="bags/foo "bar" baz"''' in string
assert r'''modifier="Chris "sensei" Dent"''' in string
assert r'''creator="Chris "sensei" Dent"''' in string
assert r'''tags="foo [[xxx "yyy" zzz]]"''' in string
assert r'''custom="lorem 'ipsum' dolor "sit" amet"''' in string
assert r'''you may still <a href="http://our_test_domain:8001/bags/foo%20%22bar%22%20baz/tiddlers">browse''' in string
def test_in_a_recipe():
bag = Bag('hi')
store.put(bag)
tiddler = Tiddler('thing1', 'hi')
tiddler.tags = ['research']
store.put(tiddler)
tiddler = Tiddler('thing2', 'hi')
store.put(tiddler)
recipe1 = Recipe('oi')
recipe1.set_recipe([('hi', 'select=tag:research')])
recipe1.store = store
recipe2 = Recipe('boi')
recipe2.set_recipe([('hi', '')])
recipe2.store = store
environ = {'tiddlyweb.store': store}
tiddlers = list(control.get_tiddlers_from_recipe(recipe1, environ))
assert len(tiddlers) == 1
tiddlers = list(control.get_tiddlers_from_recipe(recipe2, environ))
assert len(tiddlers) == 2
def test_put_and_get_dotted_file():
"""
store and retrieve a file beginning with '.'
"""
tiddlers0 = list(store.list_bag_tiddlers(Bag('bagone')))
tiddler1 = Tiddler('.profile', 'bagone')
tiddler1.text = 'alias ls ls -a'
tiddler1.tags = ['foo']
store.put(tiddler1)
tiddlers1 = list(store.list_bag_tiddlers(Bag('bagone')))
tiddler2 = Tiddler('.profile', 'bagone')
tiddler2 = store.get(tiddler2)
assert tiddler1.title == tiddler2.title
assert tiddler1.text == tiddler2.text
assert tiddler1.tags == tiddler2.tags
assert tiddler2.text == 'alias ls ls -a'
assert tiddler2.tags == ['foo']
assert len(tiddlers1) == len(tiddlers0) + 1
def test_put_tiddler_recipe_with_filter():
recipe = Recipe('recipe1')
bag1 = Bag('bag1')
bag2 = Bag('bag2')
recipe.set_recipe([('bag1', ''), ('bag2', 'select=tag:foo')])
store.put(bag1)
store.put(bag2)
store.put(recipe)
tiddler_json_one = simplejson.dumps(dict(text='hello', tags=[]))
tiddler_json_two = simplejson.dumps(dict(text='hello', tags=['foo']))
http = httplib2.Http()
response, content = http.request(
'http://our_test_domain:8001/recipes/recipe1/tiddlers/tiddler_one',
headers={'Content-Type': 'application/json'},
method='PUT',
body=tiddler_json_one)
assert response['status'] == '204'
assert 'bag1' in response['etag']
response, content = http.request(
'http://our_test_domain:8001/recipes/recipe1/tiddlers/tiddler_two',
headers={'Content-Type': 'application/json'},
method='PUT',
body=tiddler_json_two)
assert response['status'] == '204'
assert 'bag2' in response['etag']
tiddler = Tiddler('tiddler_three', 'bag2')
tiddler.tags = ['foo']
store.put(tiddler)
response, content = http.request(
'http://our_test_domain:8001/recipes/recipe1/tiddlers/tiddler_two',
headers={'Content-Type': 'application/json'},
method='PUT',
body=tiddler_json_two)
assert response['status'] == '204'
assert 'bag2' in response['etag']
def test_tiddler():
#setup
wikklytextplugins.init({})
store.put(Bag("bar"))
store.put(Bag("foo"))
recipe = Recipe("foo")
recipe.set_recipe([['foo', ''], ['bar', '']])
store.put(recipe)
tid = Tiddler("jon robson", "bar")
tid.text = "My name is Jon Robson"
store.put(tid)
tid = Tiddler("a tiddler in foo", "foo")
tid.text = "rainbow [[title]]"
store.put(tid)
tid = Tiddler("foo", "bar")
tid.tags = ['ab', 'cd', 'ef gh']
#run and verify
out = macros.tiddler(WikiContext(tid, config), WikiArgument("jon robson"))
assert 'My name is Jon Robson' in out
out = macros.tiddler(WikiContext(tid, config),
WikiArgument("a tiddler in foo"))
assert out == "" #we are viewing from bag bar not foo.
tid.recipe = "foo"
out = macros.tiddler(WikiContext(tid, config),
WikiArgument("a tiddler in foo"))
assert "rainbow" in out #we are viewing from recipe now
assert "title</a>" in out
#teardown
store.delete(Bag("foo"))
store.delete(Bag("bar"))
store.delete(Recipe("foo"))
def test_open_graph():
"""
Make sure the open graph stuff is present in the right places.
"""
http = httplib2.Http()
tiddler = Tiddler('Open Graph', 'cdent_public')
tiddler.text = 'I am the text'
tiddler.modifier = 'cdent'
tiddler.tags = ['alpha', 'beta', 'cat dog']
store.put(tiddler)
response, content = http.request('http://cdent.0.0.0.0:8080/Open%20Graph')
assert response['status'] == '200'
assert '<html prefix="og: http://ogp.me/ns#' in content
assert '<meta property="og:title" content="Open Graph" />' in content
assert '<meta property="og:url" content="http://cdent.0.0.0.0:8080/Open%20Graph" />' in content
assert '<meta property="og:image" content="http://cdent.0.0.0.0:8080/SiteIcon" />' in content
assert '<meta property="article:tag" content="alpha" />' in content
assert '<meta property="article:modified_time"' in content
assert '<meta property="article:published_time"' in content
assert '<meta property="article:author"' in content
assert '<meta property="og:site_name" content="TiddlySpace" />' in content
response, content = http.request(
'http://cdent.0.0.0.0:8080/bags/cdent_public/tiddlers/Open%20Graph')
assert response['status'] == '200'
assert '<html>' in content
assert '<html prefix>' not in content
# clean1 frields gets ogp too
tiddler = Tiddler('ServerSettings', 'cdent_public')
tiddler.text = 'htmltemplate: clean1\n'
store.put(tiddler)
response, content = http.request('http://cdent.0.0.0.0:8080/Open%20Graph')
assert response['status'] == '200'
assert '<html prefix="og: http://ogp.me/ns#' in content
def test_make_a_bunch():
for x in xrange(RANGE):
bag_name = u'bag%s' % x
recipe_name = u'recipe%s' % x
tiddler_name = u'tiddler%s' % x
recipe_list = [(bag_name, '')]
tiddler_text = u'hey ho %s' % x
field_name = u'field%s' % x
field_name2 = u'fieldone%s' % x
tag_name = u'tag%s' % x
user_name = u'user%s' % x
user_pass = u'pass%s' % x
user_note = u'note%s' % x
user_roles = [u'rolehold', u'role%s' % x]
bag = Bag(bag_name)
bag.policy.owner = u'owner%s' % x
bag.policy.read = [u'hi%s' % x, u'andextra']
bag.policy.manage = [u'R:hi%s' % x, u'andmanage']
store.put(bag)
recipe = Recipe(recipe_name)
recipe.policy.owner = u'owner%s' % x
recipe.policy.read = [u'hi%s' % x, u'andextra']
recipe.policy.manage = [u'R:hi%s' % x, u'andmanage']
recipe.set_recipe(recipe_list)
store.put(recipe)
tiddler = Tiddler(tiddler_name, bag_name)
tiddler.text = tiddler_text
tiddler.fields[field_name] = field_name
tiddler.fields[field_name2] = field_name2
tiddler.fields['server.host'] = 'gunky'
tiddler.tags = [tag_name]
store.put(tiddler)
store.put(tiddler)
user = User(user_name)
user.set_password(user_pass)
user.note = user_note
for role in user_roles:
user.add_role(role)
store.put(user)
bags = [bag.name for bag in store.list_bags()]
recipes = [recipe.name for recipe in store.list_recipes()]
users = [user.usersign for user in store.list_users()]
assert len(bags) == RANGE
assert len(recipes) == RANGE
assert len(users) == RANGE
for x in xrange(RANGE):
bname = 'bag%s' % x
rname = 'recipe%s' % x
uname = 'user%s' % x
assert bname in bags
assert rname in recipes
assert uname in users
tiddler = store.get(Tiddler(u'tiddler0', u'bag0'))
assert tiddler.fields[u'field0'] == u'field0'
assert tiddler.fields[u'fieldone0'] == u'fieldone0'
bag = Bag(u'bag0')
bag = store.get(bag)
tiddlers = []
for tiddler in store.list_bag_tiddlers(bag):
tiddlers.append(store.get(tiddler))
assert len(tiddlers) == 1
assert tiddlers[0].title == 'tiddler0'
assert tiddlers[0].fields['field0'] == 'field0'
assert tiddlers[0].fields['fieldone0'] == 'fieldone0'
assert tiddlers[0].tags == ['tag0']
assert sorted(bag.policy.read) == ['andextra', 'hi0']
assert sorted(bag.policy.manage) == ['R:hi0', u'andmanage']
assert bag.policy.owner == 'owner0'
user = User(u'user1')
user = store.get(user)
assert user.usersign == 'user1'
assert user.check_password('pass1')
assert user.note == 'note1'
assert 'role1' in user.list_roles()
assert 'rolehold' in user.list_roles()
recipe = Recipe(u'recipe2')
recipe = store.get(recipe)
assert recipe.name == 'recipe2'
bags = [bag_name for bag_name, filter in recipe.get_recipe()]
assert len(bags) == 1
assert 'bag2' in bags
assert sorted(recipe.policy.read) == ['andextra', 'hi2']
assert sorted(recipe.policy.manage) == ['R:hi2', u'andmanage']
assert recipe.policy.owner == 'owner2'
recipe.policy.manage = [u'andmanage']
store.put(recipe)
recipe = Recipe(u'recipe2')
recipe = store.get(recipe)
assert recipe.policy.manage == [u'andmanage']
# delete the above things
store.delete(bag)
py.test.raises(NoBagError, 'store.delete(bag)')
py.test.raises(NoBagError, 'store.get(bag)')
store.delete(recipe)
py.test.raises(NoRecipeError, 'store.delete(recipe)')
py.test.raises(NoRecipeError, 'store.get(recipe)')
store.delete(user)
py.test.raises(NoUserError, 'store.delete(user)')
py.test.raises(NoUserError, 'store.get(user)')
tiddler = Tiddler(u'tiddler9', u'bag9')
store.get(tiddler)
assert tiddler.bag == 'bag9'
assert tiddler.text == 'hey ho 9'
assert tiddler.tags == ['tag9']
assert tiddler.fields['field9'] == 'field9'
assert 'server.host' not in tiddler.fields
store.delete(tiddler)
py.test.raises(NoTiddlerError, 'store.delete(tiddler)')
py.test.raises(NoTiddlerError, 'store.get(tiddler)')
def edit(environ, start_response):
"""
XXX: Lots of duplication from editor.
"""
store = environ['tiddlyweb.store']
usersign = environ['tiddlyweb.usersign']
query = environ['tiddlyweb.query']
try:
bag_name = query['bag'][0]
title = query['title'][0]
text = query['text'][0]
tiddler_type = query['type'][0]
tags = query['tags'][0]
etag = query['etag'][0]
except KeyError as exc:
raise HTTP400('bad query: incomplete form, %s' % exc)
tags = [tag.strip() for tag in tags.split(',')]
if not (bag_name and title):
raise HTTP400('bad query: bag and title required')
bag = Bag(bag_name)
try:
bag = store.get(bag)
except NoBagError:
raise HTTP404('that tank does not exist')
tiddler = Tiddler(title, bag_name)
tiddler_new = False
conflict = False
try:
tiddler = store.get(tiddler)
existing_etag = tiddler_etag(environ, tiddler).replace('"',
'').split(':', 1)[0]
if etag != existing_etag:
conflict = True
except NoTiddlerError:
tiddler.type = tiddler_type
tiddler_new = True
if tiddler_new:
bag.policy.allows(usersign, 'create')
else:
bag.policy.allows(usersign, 'write')
tiddler.text = text
tiddler.tags = tags
tiddler.modifier = usersign['name']
tiddler.modified = current_timestring()
if conflict:
return editor(environ, start_response, tiddler,
message='conflict')
try:
validate_tiddler(tiddler, environ)
except InvalidTiddlerError as exc:
return editor(environ, start_response, tiddler,
message='Tiddler content is invalid: %s' % exc)
store.put(tiddler)
redirect_uri = tank_page_uri(environ, tiddler.bag, tiddler.title)
start_response('303 See Other', [
('Location', str(redirect_uri))])
return []
'host': 'our_test_domain',
'port': '8001',
}
def initialize_app():
app = load_app()
def app_fn():
return app
httplib2_intercept.install()
wsgi_intercept.add_wsgi_intercept('our_test_domain', 8001, app_fn)
TiddlerOne = Tiddler('TiddlerOne')
TiddlerOne.modifier = 'AuthorOne'
TiddlerOne.text = u'c tiddler one content'
TiddlerOne.tags = ['tagone', 'tagtwo']
TiddlerTwo = Tiddler('TiddlerTwo')
TiddlerTwo.modifier = u'AuthorTwo'
TiddlerTwo.text = u'b tiddler two content'
TiddlerThree = Tiddler('TiddlerThree')
TiddlerThree.modifier = u'AuthorThree'
TiddlerThree.text = u'a tiddler three content'
TiddlerThree.tags = [u'tagone', u'tagthree']
tiddlers = [TiddlerOne, TiddlerTwo, TiddlerThree]
bagone = Bag(name='bagone')
container = Tiddlers()
container.add(tiddlers[0])
