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 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 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_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_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_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_get_profile_html():
response, content = http.request('http://0.0.0.0:8080/profiles/cdent')
# the lack of a profile tiddler indicates you don't want to
# participate
assert response['status'] == '404', content
tiddler = Tiddler('profile', 'cdent_public')
tiddler.text = '!Hello There'
tiddler.modifier = 'cdent'
store.put(tiddler)
response, content = http.request('http://0.0.0.0:8080/profiles/cdent')
assert response['status'] == '200', content
assert 'Hello There' in content
assert '/cdent_public/tiddlers/profile' in content
response, content = http.request(
'http://cdent.0.0.0.0:8080/profiles/cdent')
assert response['status'] == '404', content
assert 'No profiles at this host' in content
response, content = http.request('http://0.0.0.0:8080/profiles/notexist')
assert response['status'] == '404', content
assert 'Profile not found for notexist' in content
def test_get_profile_html():
response, content = http.request('http://0.0.0.0:8080/profiles/cdent')
# the lack of a profile tiddler indicates you don't want to
# participate
assert response['status'] == '404', content
tiddler = Tiddler('profile', 'cdent_public')
tiddler.text = '#Hello There\n[[monkey]]'
tiddler.type = 'text/x-markdown'
tiddler.modifier = 'cdent'
store.put(tiddler)
response, content = http.request('http://0.0.0.0:8080/profiles/cdent')
assert response['status'] == '200', content
assert 'Hello There' in content
assert 'http://cdent.0.0.0.0:8080/profile' in content
assert '<li><a href="http://cdent.0.0.0.0:8080/profile">profile</a></li>' in content
assert '<base href="http://cdent.0.0.0.0:8080/"' in content
assert '<p><a class="wikilink" href="monkey">monkey</a></p>' in content
response, content = http.request('http://cdent.0.0.0.0:8080/profiles/cdent')
assert response['status'] == '404', content
assert 'No profiles at this host' in content
response, content = http.request('http://0.0.0.0:8080/profiles/notexist')
assert response['status'] == '404', content
assert 'Profile not found for notexist' in content
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_get_profile_html():
response, content = http.request('http://0.0.0.0:8080/profiles/cdent')
# the lack of a profile tiddler indicates you don't want to
# participate
assert response['status'] == '404', content
tiddler = Tiddler('profile', 'cdent_public')
tiddler.text = '#Hello There\n[[monkey]]'
tiddler.type = 'text/x-markdown'
tiddler.modifier = 'cdent'
store.put(tiddler)
response, content = http.request('http://0.0.0.0:8080/profiles/cdent')
assert response['status'] == '200', content
assert 'Hello There' in content
assert 'http://cdent.0.0.0.0:8080/profile' in content
assert '<li><a href="http://cdent.0.0.0.0:8080/profile">profile</a></li>' in content
assert '<base href="http://cdent.0.0.0.0:8080/"' in content
assert '<p><a class="wikilink" href="monkey">monkey</a></p>' in content
response, content = http.request(
'http://cdent.0.0.0.0:8080/profiles/cdent')
assert response['status'] == '404', content
assert 'No profiles at this host' in content
response, content = http.request('http://0.0.0.0:8080/profiles/notexist')
assert response['status'] == '404', content
assert 'Profile not found for notexist' in content
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_collection():
tiddlers = Tiddlers()
tiddler = Tiddler('foo', 'null')
tiddler.text = 'bam'
tiddler.modifier = 'cdent'
tiddlers.add(tiddler)
tiddler = Tiddler('bar', 'null')
tiddler.text = 'zoom'
tiddler.modifier = 'cdent'
tiddlers.add(tiddler)
output = serializer.list_tiddlers(tiddlers)
assert '<name>cdent</name>' in output
assert '<uri>http://0.0.0.0:8080/profiles/cdent</uri>' in output
assert '<link href="http://pubsubhubbub.appspot.com/" rel="hub">' in output
assert 'rel="avatar"' in output, output
def test_collection():
tiddlers = Tiddlers()
tiddler = Tiddler('foo', 'null')
tiddler.text = 'bam'
tiddler.modifier = 'cdent'
tiddlers.add(tiddler)
tiddler = Tiddler('bar', 'null')
tiddler.text = 'zoom'
tiddler.modifier = 'cdent'
tiddlers.add(tiddler)
output = serializer.list_tiddlers(tiddlers)
assert '<name>cdent</name>' in output
assert '<uri>http://0.0.0.0:8080/profiles/cdent</uri>' in output
assert '<link href="http://pubsubhubbub.appspot.com/" rel="hub">' in output
assert 'rel="avatar"' in output, output
def add_email(environ, start_response):
user = get_user_object(environ)
store = environ['tiddlyweb.store']
ensure_user_bag(store, user['name'])
tiddler = Tiddler('email', user['name'])
email = environ['tiddlyweb.query'].get('email', [''])[0]
tiddler.text = email
tiddler.modifier = user['name']
store.put(tiddler)
raise HTTP303('%s/home' % server_base_url(environ))
def add_email(environ, start_response):
user = get_user_object(environ)
store = environ['tiddlyweb.store']
ensure_user_bag(store, user['name'])
tiddler = Tiddler('email', user['name'])
email = environ['tiddlyweb.query'].get('email', [''])[0]
tiddler.text = email
tiddler.modifier = user['name']
store.put(tiddler)
raise HTTP303('%s/home' % server_base_url(environ))
def setup(self):
data = yaml.load(self.value)
self.stash['tiddlers'] = {}
for title in data:
tiddler = Tiddler(title)
tiddler.modfied = data.get('modified', '')
tiddler.tags = data.get('tags', [])
tiddler.text = data.get('text', '')
tiddler.modifier = data.get('modifier', '')
self.stash['tiddlers'][title] = tiddler
def create_test_data():
testbag = Bag(name='testbag')
WikiTextTiddler = Tiddler('WikiTextTiddler')
WikiTextTiddler.modifier = 'WikiAuthor'
WikiTextTiddler.text = u"A ''tiddler'' //with// {{{wikitext}}}"
WikiTextTiddler.bag = testbag.name
store = _get_store()
store.put(testbag)
store.put(WikiTextTiddler)
def create_test_data():
testbag = Bag(name='testbag')
WikiTextTiddler = Tiddler('WikiTextTiddler')
WikiTextTiddler.modifier = 'WikiAuthor'
WikiTextTiddler.text = u"A ''tiddler'' //with// {{{wikitext}}}"
WikiTextTiddler.bag = testbag.name
store = _get_store()
store.put(testbag)
store.put(WikiTextTiddler)
def _regular_tiddler(environ, bag_name, input_file, target_name):
store = environ['tiddlyweb.store']
username = environ['tiddlyweb.usersign']['name']
content = input_file.file.read()
tiddler = Tiddler(target_name, bag_name)
tiddler.text = content.decode('utf-8')
tiddler.modifier = username
tiddler.type = input_file.type
store.put(tiddler)
return tiddler
def _regular_tiddler(environ, bag_name, input_file, target_name):
store = environ['tiddlyweb.store']
username = environ['tiddlyweb.usersign']['name']
content = input_file.file.read()
tiddler = Tiddler(target_name, bag_name)
tiddler.text = content.decode('utf-8')
tiddler.modifier = username
tiddler.type = input_file.type
store.put(tiddler)
return tiddler
def _binary_tiddler(environ, bag_name, input_file, target_name):
store = environ['tiddlyweb.store']
username = environ['tiddlyweb.usersign']['name']
binary_storage = BinaryDisk(environ, input_file)
url = binary_storage.store()
tiddler = Tiddler(target_name, bag_name)
tiddler.fields['_canonical_uri'] = url
tiddler.modifier = username
tiddler.type = input_file.type
store.put(tiddler)
return tiddler
def add_github_gist_tiddler(self, repo):
tiddler = Tiddler('GitHubGist' + str(repo.id), 'github')
tiddler.text = repo.description
tiddler.tags = ['gitHubGist']
tiddler.fields['sort_field'] = self.get_date_string(repo.updated_at)
tiddler.fields['sort_date'] = repo.updated_at
tiddler.fields['created_at'] = repo.created_at
tiddler.fields['updated_at'] = repo.updated_at
tiddler.fields['item_summary'] = repo.description
tiddler.fields['item_url'] = repo.html_url
tiddler.modifier = 'LifeStreamDataLoader'
update = self.do_update(tiddler)
if update:
self.store.put(tiddler)
def test_tiddler_creation_info():
bag = Bag('alpha')
STORE.put(bag)
tiddler = Tiddler('Foo', bag.name)
tiddler.text = 'lorem ipsum'
tiddler.modifier = 'john'
tiddler.modified = '20130119150632'
STORE.put(tiddler)
tiddler = Tiddler('Foo', bag.name)
tiddler.text = 'lorem ipsum\ndolor sit amet'
tiddler.modifier = 'jane'
tiddler.modified = '20130119151021'
STORE.put(tiddler)
tiddler = Tiddler('Foo', bag.name)
tiddler = STORE.get(tiddler)
assert tiddler.creator == 'john'
assert tiddler.modifier == 'jane'
assert tiddler.created != tiddler.modified
assert len(tiddler.created) == 14
assert len(tiddler.fields) == 0
def _binary_tiddler(environ, bag_name, input_file, target_name):
store = environ['tiddlyweb.store']
username = environ['tiddlyweb.usersign']['name']
binary_storage = BinaryDisk(environ, input_file)
url = binary_storage.store()
tiddler = Tiddler(target_name, bag_name)
tiddler.fields['_canonical_uri'] = url
tiddler.modifier = username
tiddler.type = input_file.type
store.put(tiddler)
return 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 add_tweet_tiddler(self, tweet):
id_str = tweet['id_str']
tiddler = Tiddler('Tweet' + id_str, 'tweets')
tiddler.text = tweet['text']
tiddler.tags = ['tweet']
tiddler.fields['sort_field'] = self.format_date(tweet['created_at'], Loader.TWITTER_FORMAT)
tiddler.fields['sort_date'] = tweet['created_at']
tiddler.fields['created_at'] = tweet['created_at']
tiddler.fields['user_name'] = tweet['user']['screen_name']
tiddler.fields['item_summary'] = tweet['text']
tiddler.fields['item_url'] = 'http://twitter.com/BoyCook/status/' + id_str
tiddler.modifier = 'LifeStreamDataLoader'
update = self.do_update(tiddler)
if update:
self.store.put(tiddler)
def add_blog_post_tiddler(self, post):
tiddler = Tiddler('Blog' + str(post['ID']), 'blogs')
tiddler.text = post['content']
tiddler.tags = ['blogPost']
tiddler.fields['sort_field'] = self.format_date(post['modified'], Loader.WORDPRESS_FORMAT)
tiddler.fields['sort_date'] = post['modified']
tiddler.fields['created_at'] = post['date']
tiddler.fields['post_modified_at'] = post['modified']
tiddler.fields['item_summary'] = post['excerpt']
tiddler.fields['post_title'] = post['title']
tiddler.fields['item_url'] = post['URL']
tiddler.modifier = 'LifeStreamDataLoader'
update = self.do_update(tiddler)
if update:
self.store.put(tiddler)
def _create_tiddler(commit):
tiddler = Tiddler(commit["id"])
tiddler.bag = bag_name
#tiddler.created = commit["timestamp"] # XXX: convert timestamp
#tiddler.modified = tiddler.created # XXX: use time of notification?
tiddler.modifier = commit["author"]["name"]
tiddler.type = content_type
tiddler.fields = {
"uri": commit["url"],
"files_added": _get_file_changes(commit, "added"),
"files_removed": _get_file_changes(commit, "removed"),
"files_modified": _get_file_changes(commit, "modified")
}
tiddler.text = commit["message"]
return tiddler
def post(environ, start_response):
usersign = environ['tiddlyweb.usersign']
text = environ['tiddlyweb.query'].get('text', [''])[0]
title = environ['tiddlyweb.query'].get('title', [''])[0]
bag = environ['tiddlyweb.query'].get('bag', [''])[0]
store = environ['tiddlyweb.store']
tiddler = Tiddler(title, bag)
tiddler.text = text
tiddler.modifier = usersign['name']
bag = Bag(bag)
try:
bag = store.get(bag)
except NoBagError, exc:
raise HTTP404('tiddler %s not found: %s' % (tiddler.title, exc))
def test_get_profile_html():
response, content = http.request('http://0.0.0.0:8080/profiles/cdent')
# the lack of a profile tiddler indicates you don't want to
# participate
assert response['status'] == '404', content
tiddler = Tiddler('profile', 'cdent_public')
tiddler.text = '!Hello There'
tiddler.modifier = 'cdent'
store.put(tiddler)
response, content = http.request('http://0.0.0.0:8080/profiles/cdent')
assert response['status'] == '200', content
assert 'Hello There' in content
assert '/cdent_public/tiddlers/profile' in content
def post(environ, start_response):
usersign = environ['tiddlyweb.usersign']
text = environ['tiddlyweb.query'].get('text', [''])[0]
title = environ['tiddlyweb.query'].get('title', [''])[0]
bag = environ['tiddlyweb.query'].get('bag', [''])[0]
store = environ['tiddlyweb.store']
tiddler = Tiddler(title, bag)
tiddler.text = text
tiddler.modifier = usersign['name']
bag = Bag(bag)
try:
bag = store.get(bag)
except NoBagError, exc:
raise HTTP404('tiddler %s not found: %s' % (tiddler.title, exc))
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 create(environ, start_response):
store = environ['tiddlyweb.store']
username = environ['tiddlyweb.usersign']['name']
query = environ['tiddlyweb.query']
title = query['title'][0]
text = query['text'][0]
tiddler = Tiddler(title, 'common')
tiddler.text = text
tiddler.modifier = username
store.put(tiddler)
start_response('303 Found', [('Location', tiddler_url(environ, tiddler))])
return []
def _regular_tiddler(environ, bag_name, input_file, target_name):
store = environ['tiddlyweb.store']
username = environ['tiddlyweb.usersign']['name']
content = input_file.file.read()
tiddler = Tiddler(target_name, bag_name)
try:
tiddler.text = content.decode('utf-8')
except UnicodeError as exc:
raise HTTP400('tiddler content should be utf-8 encode: %s' % exc)
tiddler.modifier = username
tiddler.type = input_file.type
store.put(tiddler)
return tiddler
def test_get_tiddler_revision():
_cleanup()
config = { "server_store": ["tiddlywebplugins.devstore", { "store_root": STORE_DIR }],
"instance_tiddlers": {
"myBag": ["%s/alpha/index.recipe" % REPO_DIR]
},
"root_dir": ""
}
env = { "tiddlyweb.config": config }
store = Store(config["server_store"][0], config["server_store"][1], env)
tiddler = Tiddler("lorem")
tiddler.bag = "myBag"
t = store.get(tiddler)
assert t.title == "lorem"
assert t.bag == "myBag"
assert t.revision == 1
assert t.tags == []
assert t.creator == "FND"
assert t.modifier == "FND"
assert len(t.created) == 14
assert len(t.modified) == 14
assert t.created == t.modified
assert t.text == "lorem ipsum"
tiddler = Tiddler("hello world")
tiddler.bag = "myBag"
tiddler.tags = ["foo", "bar"]
tiddler.modifier = "FND"
tiddler.text = "lorem ipsum"
store.put(tiddler)
tiddler = Tiddler("hello world")
tiddler.bag = "myBag"
t = store.get(tiddler)
assert t.title == "hello world"
assert t.bag == "myBag"
assert t.revision == 1
assert t.tags == ["foo", "bar"]
assert t.creator == "FND"
assert t.modifier == "FND"
assert len(t.created) == 14
assert len(t.modified) == 14
assert t.created == t.modified
assert t.text == "lorem ipsum"
def post_tiddler_edit(environ, start_response):
usersign = environ["tiddlyweb.usersign"]
text = environ["tiddlyweb.query"].get("text", [""])[0]
title = environ["tiddlyweb.query"].get("title", [""])[0]
bag = environ["tiddlyweb.query"].get("bag", [""])[0]
return_url = environ["tiddlyweb.query"].get("return_url", [""])[0]
store = environ["tiddlyweb.store"]
tiddler = Tiddler(title, bag)
tiddler.text = text
tiddler.modifier = usersign["name"]
bag = Bag(bag)
try:
bag = store.get(bag)
except NoBagError, exc:
raise HTTP404("tiddler %s not found: %s" % (tiddler.title, exc))
def add_friend(environ, start_response):
user = get_user_object(environ)
store = environ['tiddlyweb.store']
ensure_user_bag(store, user['name'])
new_friend = environ['tiddlyweb.query'].get('name', [''])[0]
friends = get_friends(store, user['name'])
if new_friend and new_friend not in friends:
friends.append(new_friend)
tiddler = Tiddler('friends', user['name'])
try:
tiddler = store.get(tiddler)
except NoTiddlerError:
pass # is okay if tiddler doesn't exist yet
tiddler.text = '\n'.join(friends)
tiddler.modifier = user['name']
store.put(tiddler)
raise HTTP303('%s/home' % server_base_url(environ))
def add_friend(environ, start_response):
user = get_user_object(environ)
store = environ['tiddlyweb.store']
ensure_user_bag(store, user['name'])
new_friend = environ['tiddlyweb.query'].get('name', [''])[0]
friends = get_friends(store, user['name'])
if new_friend and new_friend not in friends:
friends.append(new_friend)
tiddler = Tiddler('friends', user['name'])
try:
tiddler = store.get(tiddler)
except NoTiddlerError:
pass # is okay if tiddler doesn't exist yet
tiddler.text = '\n'.join(friends)
tiddler.modifier = user['name']
store.put(tiddler)
raise HTTP303('%s/home' % server_base_url(environ))
def create(environ, start_response):
store = environ['tiddlyweb.store']
username = environ['tiddlyweb.usersign']['name']
query = environ['tiddlyweb.query']
title = query['title'][0]
text = query['text'][0]
tiddler = Tiddler(title, 'common')
tiddler.text = text
tiddler.modifier = username
store.put(tiddler)
start_response('303 Found', [
('Location', tiddler_url(environ, tiddler))])
return []
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 bag_favor(environ, start_response):
user = get_user_object(environ)
store = environ['tiddlyweb.store']
ensure_user_bag(store, user['name'])
new_favorite = environ['tiddlyweb.query'].get('bag', [''])[0]
favorites = get_favorites(store, user['name'])
# XXX I suppose a set would be okay here.
if new_favorite and new_favorite not in favorites:
favorites.append(new_favorite)
tiddler = Tiddler('favorites', user['name'])
try:
tiddler = store.get(tiddler)
except NoTiddlerError:
pass # is okay if tiddler doesn't exist yet
tiddler.text = '\n'.join(favorites)
tiddler.modifier = user['name']
store.put(tiddler)
raise HTTP303('%s/home' % server_base_url(environ))
def bag_favor(environ, start_response):
user = get_user_object(environ)
store = environ['tiddlyweb.store']
ensure_user_bag(store, user['name'])
new_favorite = environ['tiddlyweb.query'].get('bag', [''])[0]
favorites = get_favorites(store, user['name'])
# XXX I suppose a set would be okay here.
if new_favorite and new_favorite not in favorites:
favorites.append(new_favorite)
tiddler = Tiddler('favorites', user['name'])
try:
tiddler = store.get(tiddler)
except NoTiddlerError:
pass # is okay if tiddler doesn't exist yet
tiddler.text = '\n'.join(favorites)
tiddler.modifier = user['name']
store.put(tiddler)
raise HTTP303('%s/home' % server_base_url(environ))
def recipe_favor(environ, start_response):
user = get_user_object(environ)
store = environ['tiddlyweb.store']
ensure_user_bag(store, user['name'])
new_bookmark = environ['tiddlyweb.query'].get('recipe', [''])[0]
bookmarks = get_bookmarks(store, user['name'])
# XXX I suppose a set would be okay here.
if new_bookmark and new_bookmark not in bookmarks:
bookmarks.append(new_bookmark)
tiddler = Tiddler('bookmarks', user['name'])
try:
tiddler = store.get(tiddler)
except NoTiddlerError:
pass # is okay if tiddler doesn't exist yet
tiddler.text = '\n'.join(bookmarks)
tiddler.modifier = user['name']
store.put(tiddler)
raise HTTP303('%s/home' % server_base_url(environ))
def recipe_favor(environ, start_response):
user = get_user_object(environ)
store = environ['tiddlyweb.store']
ensure_user_bag(store, user['name'])
new_bookmark = environ['tiddlyweb.query'].get('recipe', [''])[0]
bookmarks = get_bookmarks(store, user['name'])
# XXX I suppose a set would be okay here.
if new_bookmark and new_bookmark not in bookmarks:
bookmarks.append(new_bookmark)
tiddler = Tiddler('bookmarks', user['name'])
try:
tiddler = store.get(tiddler)
except NoTiddlerError:
pass # is okay if tiddler doesn't exist yet
tiddler.text = '\n'.join(bookmarks)
tiddler.modifier = user['name']
store.put(tiddler)
raise HTTP303('%s/home' % server_base_url(environ))
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_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 create(name=None, owner=None, app_url=None,
callback_url=None, logo=None):
"""
Create a tiddler representing a client app.
"""
if not name or not owner or not app_url or not callback_url:
raise TypeError('name, owner, app_url and callback_url required')
client_id = str(uuid4())
client_secret = str(uuid4())
client = Tiddler(client_id)
client.modifier = owner
client.fields = {
'client_secret': client_secret,
'name': name,
'app_url': app_url,
'callback_url': callback_url}
if logo:
client.fields['logo'] = logo
return client
def test_html_attribute_escape_with_recipe():
tiddler = Tiddler('escape "double" quotes in tiddler field values')
tiddler.bag = 'foo "bar" baz'
tiddler.recipe = 'baz "bar" foo'
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'''recipe="baz "bar" foo"''' 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://0.0.0.0:8080/recipes/baz%20%22bar%22%20foo/tiddlers">browse''' in string
def register_code(environ, user, client, redirect, scope=None):
"""
Create and save a unique code for this authorization.
"""
config = environ['tiddlyweb.config']
store = environ['tiddlyweb.store']
if scope is None:
scope = []
code = str(uuid4())
registration = Tiddler(code)
registration.modifier = user
registration.fields = dict(client=client,
redirect_uri=redirect,
scope=','.join(scope))
bag_name = config.get('oauth.registrations_bag', 'oauth_registrations')
registration.bag = bag_name
store.put(registration)
return code
def make_space(space_name, store, member):
"""
The details of creating the bags and recipes that make up a space.
"""
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)
info_tiddler = Tiddler('SiteInfo', space.public_bag())
info_tiddler.text = 'Space %s' % space_name
info_tiddler.modifier = store.environ.get('tiddlyweb.usersign',
{}).get('name', 'GUEST')
store.put(info_tiddler)
# Duplicate GettingStarted into public bag.
getting_started_tiddler = Tiddler(GETTING_STARTED_TIDDLER['title'],
GETTING_STARTED_TIDDLER['bag'])
try:
getting_started_tiddler = store.get(getting_started_tiddler)
getting_started_tiddler.bag = space.public_bag()
store.put(getting_started_tiddler)
except StoreError:
pass
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 make_access_token(environ,
user,
client,
scope='',
token_type='bearer',
expires_in=None):
"""
Create an access token for a user from a particular client and scope.
"""
config = environ['tiddlyweb.config']
store = environ['tiddlyweb.store']
bag_name = config.get('oauth.tokens_bag', 'oauth_tokens')
code = str(uuid4())
token = Tiddler(code, bag_name)
token.modifier = user
token.fields = {'token_type': token_type, 'client': client, 'scope': scope}
if expires_in:
token.fields['expires_in'] = expires_in
store.put(token)
return token
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
""" # cosmic rays have injected noise into this tiddler string bad_string = """modifiXr: [email protected] created: modiFied: 200803030303 type: None tags:foobar [[foo bar]] Hello, I'm the content. """ expected_json_string = '{"created": "", "text": "Hello, I\'m the content.", "modifier": "*****@*****.**", "modified": "200803030303", "tags": ["foobar", "foo bar"]}' tiddler = Tiddler('test tiddler') tiddler.modifier = '*****@*****.**' tiddler.tags = ['foobar', 'foo bar'] tiddler.text = "Hello, I'm the content." tiddler.modified = '200803030303' def setup_module(module): pass def test_generated_txt_string(): serializer = Serializer('text') serializer.object = tiddler string = serializer.to_string() assert string == expected_string, \
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 []
def tiddlers_from_rss(rss_url):
"""Import an rss feed into a bag using a given rule number <url> <bag>"""
DEFAULT_TIDDLER_TEXT = u"<html><p><a href=\"%s\">%s</a><br/>%s</p></html>"
h = httplib2.Http()
try:
resp, content = h.request(rss_url, method='GET')
except httplib2.RelativeURIError:
try:
content = open(rss_url, "r")
content = "".join(content.readlines())
except IOError:
content = ""
resp = {"status": 200}
content = content.replace(
"media:thumbnail", "media_thumbnail"
) #this is a workaround to allow media thumbnails to work.
content = content.replace(
"media:content", "media_thumbnail"
) #this is a workaround to allow media thumbnails to work.
feed = feedparser.parse(content)
print "url returned status code %s" % resp["status"]
tiddlers = []
for entry in feed.entries:
try:
unique_title = entry.id
except AttributeError:
try:
unique_title = entry.link
except AttributeError:
unique_title = "%s_%s" % (entry.title, rss_url)
unique_title = unique_title.replace("/", "_").replace(".",
"_").replace(
":", "_")
imtiddler = Tiddler(unique_title)
imtiddler.fields[
"heading"] = entry.title #save the original title for display purposes
tags = []
try:
for tag in entry.tags:
tags.append("[" + tag.term + "]")
except AttributeError:
pass
imtiddler.tags = tags
description = None
try:
description = entry.summary
except AttributeError:
try:
description = entry.content[0]["value"]
except AttributeError:
description = u"No description."
try:
imtiddler.modifier = entry.author
except AttributeError:
imtiddler.modifier = "Unknown"
try:
posted_date = entry["updated_parsed"]
yr = posted_date[0]
mo = posted_date[1]
dy = posted_date[2]
hr = posted_date[3]
mi = posted_date[4]
sec = posted_date[5]
imtiddler.modified = "%02d%02d%02d%02d%02d%02d" % (yr, mo, dy, hr,
mi, sec)
except KeyError:
pass #use default
if "pos" in entry:
longlat = entry["pos"].split(" ")
imtiddler.fields["geo.lat"] = longlat[0]
imtiddler.fields["geo.long"] = longlat[1]
elif "point" in entry:
longlat = entry["point"].split(" ")
imtiddler.fields["geo.lat"] = longlat[0]
imtiddler.fields["geo.long"] = longlat[1]
try:
link = entry.link
except AttributeError:
link = ""
imtiddler.text = DEFAULT_TIDDLER_TEXT % (link, entry.title,
description)
imtiddler.fields.update({"rssurl": rss_url})
try:
name = config['imrss']['module']
f = __import__(name, fromlist=True)
imtiddler = f.handler(rss_url, imtiddler, entry, feed=feed)
except KeyError:
pass
if imtiddler:
tiddlers.append(imtiddler)
print "tiddlers ready for store (%s)" % (len(tiddlers))
return tiddlers
config['server_host'] = {
'scheme': 'http',
'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')
