def test_create_map_uses_user():
global AUTH_COOKIE
http = httplib2.Http()
response, content = http.request(
'http://0.0.0.0:8080/challenge/cookie_form',
body='user=cdent&password=cow',
method='POST',
headers={'Content-Type': 'application/x-www-form-urlencoded'})
assert response.previous['status'] == '303'
user_cookie = response.previous['set-cookie']
cookie = Cookie.SimpleCookie()
cookie.load(user_cookie)
AUTH_COOKIE = cookie['tiddlyweb_user'].value
bad_second_cookie = make_cookie('tiddlyweb_secondary_user',
'x.auth.thing',
mac_key='slippy')
mismatch_second_cookie = make_cookie('tiddlyweb_secondary_user',
'y.auth.thing',
mac_key=secret)
second_cookie = make_cookie('tiddlyweb_secondary_user',
'x.auth.thing',
mac_key=secret)
# we must have the second cookie
response, content = http.request(
'http://0.0.0.0:8080/bags/MAPUSER/tiddlers/x.auth.thing',
method='PUT',
headers={
'Content-Type': 'application/json',
'Cookie': 'tiddlyweb_user="******"' % AUTH_COOKIE
},
body='{"text":"house"}')
assert response['status'] == '409', content
assert 'secondary cookie not present' in content
response, content = http.request(
'http://0.0.0.0:8080/bags/MAPUSER/tiddlers/x.auth.thing',
method='PUT',
headers={
'Content-Type': 'application/json',
'Cookie':
'tiddlyweb_user="******"; %s' % (AUTH_COOKIE, bad_second_cookie)
},
body='{"text":"house"}')
assert response['status'] == '409', content
assert 'secondary cookie invalid' in content
response, content = http.request(
'http://0.0.0.0:8080/bags/MAPUSER/tiddlers/x.auth.thing',
method='PUT',
headers={
'Content-Type':
'application/json',
'Cookie':
'tiddlyweb_user="******"; %s' % (AUTH_COOKIE, mismatch_second_cookie)
},
body='{"text":"house"}')
assert response['status'] == '409', content
assert 'secondary cookie mismatch' in content
response, content = http.request(
'http://0.0.0.0:8080/bags/MAPUSER/tiddlers/x.auth.thing',
method='PUT',
headers={
'Content-Type': 'application/json',
'Cookie': 'tiddlyweb_user="******"; %s' % (AUTH_COOKIE, second_cookie)
},
body='{"text":"house"}')
assert response['status'] == '204'
response, content = http.request(
'http://0.0.0.0:8080/bags/MAPUSER/tiddlers/x.auth.thing',
method='GET',
headers={
'Accept': 'application/json',
'Cookie': 'tiddlyweb_user="******"; %s' % (AUTH_COOKIE, second_cookie)
})
assert response['status'] == '403'
assert 'may not read' in content
tiddler = Tiddler('x.auth.thing', 'MAPUSER')
tiddler = store.get(tiddler)
assert tiddler.modifier == 'cdent'
assert tiddler.text == ''
assert 'mapped_user' in tiddler.fields
assert tiddler.fields['mapped_user'] == 'cdent'
response, content = http.request(
'http://0.0.0.0:8080/bags/MAPUSER/tiddlers/x.auth.thing',
method='PUT',
headers={
'Content-Type': 'application/json',
'Cookie': 'tiddlyweb_user="******"; %s' % (AUTH_COOKIE, second_cookie)
},
body='{}')
assert response['status'] == '403'
assert 'may not write' in content
def test_space_server_settings_twrelease():
http = httplib2.Http()
response, content = http.request('http://foo.0.0.0.0:8080/')
assert response['status'] == '200'
assert '/bags/common/tiddlers/beta_jquery.js' not in content
response, content = http.request('http://foo.0.0.0.0:8080/tiddlers.wiki')
assert response['status'] == '200'
assert '/bags/common/tiddlers/beta_jquery.js' not in content
assert 'TiddlyWiki created by Jeremy Ruston' in content
response, content = http.request('http://foo.0.0.0.0:8080/tiddlers',
headers={'Accept': 'text/x-tiddlywiki'})
assert response['status'] == '200'
assert '/bags/common/tiddlers/beta_jquery.js' not in content
assert 'TiddlyWiki created by Jeremy Ruston' in content
tiddler = Tiddler('ServerSettings', 'foo_public')
tiddler.text = 'external: True\ntwrelease:beta'
store.put(tiddler)
tiddler2 = Tiddler('fooSetupFlag', 'foo_public')
store.put(tiddler2)
response, content = http.request('http://foo.0.0.0.0:8080/')
assert response['status'] == '200', content
assert '/bags/common/tiddlers/beta_jquery.js' in content
response, content = http.request('http://foo.0.0.0.0:8080/tiddlers',
headers={'Accept': 'text/x-tiddlywiki'})
assert response['status'] == '200'
assert '/bags/common/tiddlers/beta_jquery.js' in content
assert 'TiddlyWiki created by Jeremy Ruston' in content
# bad content
tiddler = Tiddler('ServerSettings', 'foo_public')
tiddler.text = 'external: True\ntwrelease=beta'
store.put(tiddler)
response, content = http.request('http://foo.0.0.0.0:8080/')
assert response['status'] == '200'
assert '/bags/common/tiddlers/beta_jquery.js' not in content
# ignored blank line
tiddler = Tiddler('ServerSettings', 'foo_public')
tiddler.text = 'external: True\n\ntwrelease:beta'
store.put(tiddler)
response, content = http.request('http://foo.0.0.0.0:8080/')
assert response['status'] == '200'
assert '/bags/common/tiddlers/beta_jquery.js' in content
# externalized but not beta
tiddler = Tiddler('ServerSettings', 'foo_public')
tiddler.text = 'external: True'
store.put(tiddler)
response, content = http.request('http://foo.0.0.0.0:8080/')
assert response['status'] == '200', content
assert '/bags/common/tiddlers/jquery.js' in content
response, content = http.request('http://foo.0.0.0.0:8080/tiddlers',
headers={'Accept': 'text/x-tiddlywiki'})
assert response['status'] == '200'
assert '/bags/common/tiddlers/jquery.js' in content
assert '/bags/common/tiddlers/twcore.js' in content
assert 'TiddlyWiki created by Jeremy Ruston' in content
response, content = http.request(
'http://foo.0.0.0.0:8080/bags/common/tiddlers/twcore.js')
assert response['status'] == '200'
def tiddler_from_result(result):
print 'r', result
bag, title = result['id'].split(':', 1)
tiddler = Tiddler(title, bag)
return tiddler
from tiddlywebplugins.wikklytextplugins.plugins import macros
from tiddlyweb.model.tiddler import Tiddler
from tiddlywebplugins import wikklytextplugins
from tiddlywebplugins import wikklytextrender
from tiddlyweb.config import config
from test_common import WikiArgument,WikiContext
test_tiddler= Tiddler("Test Tiddler","bag")
test_tiddler.modified = "20071003201000"
test_tiddler.revision = 2
def test_view_date():
out = macros.view(WikiContext(test_tiddler,{}), WikiArgument("modified"),WikiArgument("date"))
assert '03 October 2007' in out
def test_view_text():
text ="My name is the test tiddler!"
test_tiddler.text = text
test_tiddler.tags = ["jon","ben","jeremy ruston"]
out = macros.view(WikiContext(test_tiddler,{}), WikiArgument("text"))
assert text in out
out = macros.view(WikiContext(test_tiddler,{}), WikiArgument("text"),WikiArgument("text"))
assert text in out
out = macros.view(WikiContext(test_tiddler,{}), WikiArgument("title"),WikiArgument("text"))
assert 'Test Tiddler' in out
out = macros.view(WikiContext(test_tiddler,{}), WikiArgument("server.bag"),WikiArgument("text"))
assert 'bag' in out
out = macros.view(WikiContext(test_tiddler,{}), WikiArgument("server.page.revision"),WikiArgument("text"))
assert '2' in out
def test_tiddler_no_bag():
tiddler = Tiddler(u'hi')
py.test.raises(NoBagError, 'store.put(tiddler)')
def test_tiddler_create():
tiddler = Tiddler('hello')
assert type(tiddler) == Tiddler, ('Tiddler returns a Tiddler, %s, %s' %
(type(tiddler), Tiddler))
assert 'hello<tiddlyweb.model.tiddler.Tiddler object' in '%s' % tiddler
def test_bags_tiddlers():
for i in xrange(50):
store.put(Tiddler(str(i), 'bagone'))
bag = store.get(Bag('bagone'))
tiddlers = list(control.get_tiddlers_from_bag(bag))
assert len(tiddlers) == 51
for attribute in span.attributes.keys():
if attribute == 'tiddler':
attr = span.attributes[attribute]
interior_title = attr.value
try:
span_class = span.attributes['class'].value
if span_class.startswith('@'):
interior_bag = span_class[1:] + '_public'
else:
interior_bag = ''
except KeyError:
interior_bag = ''
title_semaphore = '%s:%s' % (interior_title, interior_bag)
if title_semaphore not in seen_titles:
seen_titles.append(title_semaphore)
interior_tiddler = Tiddler(interior_title)
try:
store = environ['tiddlyweb.store']
if interior_bag:
public_bag = store.get(Bag(interior_bag))
public_bag.policy.allows(
environ['tiddlyweb.usersign'], 'read')
interior_tiddler.bag = interior_bag
else:
if tiddler.recipe:
interior_tiddler.recipe = tiddler.recipe
recipe = store.get(Recipe(tiddler.recipe))
interior_tiddler.bag = determine_bag_from_recipe(
recipe, interior_tiddler, environ).name
else:
interior_tiddler.bag = tiddler.bag
def test_safe_exists():
global AUTH_COOKIE
response, content = http.request(
'http://0.0.0.0:8080/challenge/tiddlywebplugins.tiddlyspace.cookie_form',
body='user=cdent&password=cow',
method='POST',
headers={'Content-Type': 'application/x-www-form-urlencoded'})
assert response.previous['status'] == '303'
user_cookie = response.previous['set-cookie']
cookie = Cookie.SimpleCookie()
cookie.load(user_cookie)
AUTH_COOKIE = cookie['tiddlyweb_user'].value
response, content = http.request('http://cdent.0.0.0.0:8080/_safe',
method='GET',
headers={
'Accept':
'application/json',
'Cookie':
'tiddlyweb_user="******"' % AUTH_COOKIE
})
assert response['status'] == '200'
assert 'form' in content
assert 'Are you sure' in content
response, content = http.request('http://cdent.0.0.0.0:8080/_safe',
method='POST',
headers={
'Content-Type':
'application/json',
'Cookie':
'tiddlyweb_user="******"' % AUTH_COOKIE
})
assert response['status'] == '200'
tiddlers = simplejson.loads(content)
tiddlers_info = [(tiddler['title'], tiddler['bag'])
for tiddler in tiddlers]
bags = set(bag for title, bag in tiddlers_info)
assert sorted(list(bags)) == [
'system', 'system-images_public', 'system-info_public',
'system-plugins_public', 'system-theme_public', 'tiddlyspace'
]
assert ('TiddlyWebAdaptor', 'system') in tiddlers_info
tiddler = Tiddler('cdentSetupFlag', 'cdent_private')
store.put(tiddler)
response, content = http.request('http://cdent.0.0.0.0:8080/',
method='GET',
headers={
'Accept':
'application/json',
'Cookie':
'tiddlyweb_user="******"' % AUTH_COOKIE
})
assert response['status'] == '200'
tiddlers = simplejson.loads(content)
tiddlers_info = [(tiddler['title'], tiddler['bag'])
for tiddler in tiddlers]
bags = set(bag for title, bag in tiddlers_info)
assert sorted(list(bags)) == [
'cdent_private', 'system', 'system-images_public',
'system-info_public', 'system-plugins_public', 'system-theme_public',
'tiddlyspace'
]
assert ('TiddlyWebAdaptor', 'system') in tiddlers_info
def add_magic_tiddler(bag, title, text):
tiddler = Tiddler(title, 'tmp')
tiddler.text = text
tiddler.tags = ['excludeLists']
bag.add_tiddler(tiddler)
def _make_tiddler(result_dict):
tiddler = Tiddler(result_dict['title'])
tiddler.bag = result_dict['bag']
tiddler.revision = result_dict['revision']
return tiddler
tiddler = Tiddler(title, 'tmp')
tiddler.text = text
tiddler.tags = ['excludeLists']
bag.add_tiddler(tiddler)
add_magic_tiddler(
output_bag, 'MainMenu',
'[[Back to TiddlyWeb|%s]]' % tiddler_url(environ, tiddler))
add_magic_tiddler(output_bag, 'DefaultTiddlers', '[[%s]]' % tiddler_name)
add_magic_tiddler(output_bag, 'SiteTitle', 'Editor for %s' % tiddler_name)
add_magic_tiddler(output_bag, 'SiteSubtitle', '')
add_magic_tiddler(output_bag, 'SideBarOptions', '')
for required_tiddler in environ['tiddlyweb.config'].get(
'tiddlyeditor_tiddlers', []):
r_tiddler = Tiddler(required_tiddler[1], required_tiddler[0])
r_tiddler = store.get(r_tiddler)
if 'excludeLists' not in r_tiddler.tags:
r_tiddler.tags.append('excludeLists')
output_bag.add_tiddler(r_tiddler)
environ['tiddlyweb.type'] = 'text/x-tiddlywiki'
return send_tiddlers(environ, start_response, output_bag)
original_footer_extra = HTMLPresenter.footer_extra
def edit_link(self, environ):
output = original_footer_extra(self, environ)
if 'tiddlyeditor_tiddlers' in environ['tiddlyweb.config']:
def setup_module(module):
tiddler = Tiddler('foo')
tiddler.text = '!Hello'
module.tiddler = tiddler
def test_put_no_bag():
tiddler = Tiddler('hi')
with py.test.raises(NoBagError):
store.put(tiddler)
def test_tiddler_no_text():
serializer = Serializer('text')
tiddler = Tiddler('hello')
serializer.object = tiddler
header, body = serializer.to_string().split('\n\n')
assert 'None' not in body
def setup_module(module):
module.tiddler = Tiddler('hi', 'bagone')
tiddler.text = '!Hello'
def test_bad_string_raises():
serializer = Serializer('text')
foobar = Tiddler('foobar')
serializer.object = foobar
py.test.raises(TiddlerFormatError, 'serializer.from_string(bad_string)')
def _get_tiddler(bagname, tiddlertitle):
store = get_store(config)
tiddler = Tiddler(tiddlertitle, bagname)
return store.get(tiddler)
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]
def test_precedence_in_markdown_link():
tiddler = Tiddler('Foo')
environ = { 'tiddlyweb.config': { 'markdown.wiki_link_base': '' } }
tiddler.text = 'I see [foo LoremIpsum bar](http://example.org) you'
output = render(tiddler, environ)
assert output == '<p>I see <a href="http://example.org">foo LoremIpsum bar</a>you</p>'
def test_delete_tiddler():
tiddler = Tiddler('revised', 'bagone')
store.delete(tiddler)
py.test.raises(NoTiddlerError, 'store.get(tiddler)')
"""
Test the abilities of the limit filter.
This is not about query parsing, but rather
handling once we have the filter.
"""
import py.test
from tiddlyweb.model.tiddler import Tiddler
from tiddlyweb.filters.limit import limit
from tiddlyweb.filters import parse_for_filters, recursive_filter, FilterError
tiddlers = [Tiddler('1'), Tiddler('c'), Tiddler('a'), Tiddler('b')]
def test_simple_limit():
limited_tiddlers = limit(tiddlers, count=2)
assert ['1', 'c'] == [tiddler.title for tiddler in limited_tiddlers]
def test_ranged_limit():
limited_tiddlers = limit(tiddlers, index=1, count=2)
assert ['c', 'a'] == [tiddler.title for tiddler in limited_tiddlers]
def test_negative_limit():
with py.test.raises(ValueError):
limit(tiddlers, index=-1, count=2)
def _process_for_transclusion(output, tiddler, environ):
"""
Process the output for transclusions.
"""
if 'twikified.seen_titles' in environ:
seen_titles = environ['twikified.seen_titles']
else:
seen_titles = []
parser = html5lib.HTMLParser(
tree=html5lib.treebuilders.getTreeBuilder("dom"))
output = output.decode('utf-8', 'replace')
try:
dom = parser.parse('<div>' + output + '</div>')
spans = dom.getElementsByTagName('span')
for span in spans:
for attribute in span.attributes.keys():
if attribute == 'tiddler':
attr = span.attributes[attribute]
interior_title = attr.value
try:
span_class = span.attributes['class'].value
if span_class.startswith('@'):
interior_recipe = span_class[1:] + '_public'
else:
interior_recipe = ''
except KeyError:
interior_recipe = ''
title_semaphore = '%s:%s' % (interior_title,
interior_recipe)
if title_semaphore not in seen_titles:
seen_titles.append(title_semaphore)
interior_tiddler = Tiddler(interior_title)
try:
store = environ['tiddlyweb.store']
if interior_recipe:
recipe = store.get(Recipe(interior_recipe))
interior_tiddler.recipe = interior_recipe
interior_tiddler.bag = (
determine_bag_from_recipe(
recipe, interior_tiddler,
environ).name)
else:
if tiddler.recipe:
interior_tiddler.recipe = tiddler.recipe
recipe = store.get(Recipe(tiddler.recipe))
interior_tiddler.bag = (
determine_bag_from_recipe(
recipe, interior_tiddler,
environ).name)
else:
interior_tiddler.bag = tiddler.bag
interior_bag = store.get(Bag(interior_tiddler.bag))
interior_bag.policy.allows(
environ['tiddlyweb.usersign'], 'read')
interior_tiddler = store.get(interior_tiddler)
except (StoreError, PermissionsError):
continue
if renderable(interior_tiddler, environ):
environ['twikified.seen_titles'] = seen_titles
interior_content = render_wikitext(
interior_tiddler, environ)
interior_dom = parser.parse('<div>' +
interior_content +
'</div>')
span.appendChild(
interior_dom.getElementsByTagName('div')[0])
output = dom.getElementsByTagName('div')[0].toxml()
except ExpatError, exc:
# If expat couldn't process the output, we need to make it
# unicode as what came over the socket was utf-8 but expat
# needs that in the first place.
LOGGER.warn('got expat error: %s:%s %s', tiddler.bag, tiddler.title,
exc)
output = output.decode('utf-8', 'replace')
def search(self, search_query=''):
full_access = self._determine_user_access()
logging.debug('full_access: '+str(full_access))
open_fields = self.environ[
'tiddlyweb.config'].get(
'mappingsql.open_fields', [])
query = self.environ.get('tiddlyweb.query', {})
try:
slice_index = int(query['index'][0])
del query['index']
self.environ['tiddlyweb.mappingsql.index'] = slice_index
except KeyError:
slice_index = 0
query_string, fields = query_dict_to_search_tuple(
self.environ.get('tiddlyweb.query', {}))
query = self.session.query(getattr(sTiddler, self.id_column))
have_query = False
if query_string:
if self.environ['tiddlyweb.config'].get('mappingsql.full_text', False):
query = query.filter(
'MATCH(%s) AGAINST(:query in boolean mode)' %
','.join(
self.environ['tiddlyweb.config']
['mappingsql.default_search_fields'])
).params(query=query_string)
else:
# XXX: id and modifier fields are not guaranteed to be
# present. i.e. this code is wrong!
query = query.filter(or_(
sTiddler.id.like('%%%s%%' % query_string),
sTiddler.modifier.like('%%%s%%' % query_string)))
have_query = True
for field in fields:
if open_fields and not full_access and field not in open_fields:
continue
terms = fields[field]
# TODO: For now we only accept the first term provided
query = query.filter(getattr(sTiddler, field)==terms[0])
have_query = True
count = 0
if have_query:
limit = self.environ['tiddlyweb.config'].get('mappingsql.limit', 50)
count = query.count()
logging.debug('count is: %s', count)
self.environ['tiddlyweb.mappingsql.count'] = count
tasters = self.environ[
'tiddlyweb.config'].get(
'mappingsql.tasters', False)
if tasters and not full_access:
query = query.filter(sTiddler.taster=='Y')
access_count = query.count()
logging.debug('access_count is: %s', access_count)
self.environ['tiddlyweb.mappingsql.access_count'] = access_count
logging.debug('query is: %s', query)
stiddlers = query.slice(slice_index, slice_index + limit).all()
else:
stiddlers = []
bag_name = self.environ['tiddlyweb.config']['mappingsql.bag']
tiddlers = (Tiddler(
unicode(getattr(stiddler, self.id_column)), bag_name)
for stiddler in stiddlers)
return tiddlers
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 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
def test_space_has_limited_view():
make_fake_space(store, 'other')
http = httplib2.Http()
response, content = http.request('http://thing.0.0.0.0:8080/recipes',
method='GET')
assert response['status'] == '200', content
assert 'other_' not in content, content
assert 'thing_' in content, content
response, content = http.request('http://thing.0.0.0.0:8080/bags',
method='GET')
assert response['status'] == '200'
assert 'other_' not in content, content
assert 'thing_' in content, content
response, content = http.request(
'http://thing.0.0.0.0:8080/bags/thing_public/tiddlers', method='GET')
assert response['status'] == '200'
response, content = http.request(
'http://thing.0.0.0.0:8080/bags/other_public/tiddlers', method='GET')
assert response['status'] == '404', content
response, content = http.request('http://other.0.0.0.0:8080/bags',
method='GET')
assert response['status'] == '200', content
assert 'other_' in content, content
assert 'thing_' not in content, content
response, content = http.request('http://0.0.0.0:8080/bags', method='GET')
assert response['status'] == '200', content
assert 'other_' in content, content
assert 'thing_' in content, content
response, content = http.request(
'http://thing.0.0.0.0:8080/bags/thing_public/tiddlers', method='GET')
assert response['status'] == '200', content
response, content = http.request(
'http://thing.0.0.0.0:8080/bags/other_public/tiddlers', method='GET')
assert response['status'] == '404', content
tiddler1 = Tiddler('tiddler1', 'thing_public')
tiddler2 = Tiddler('tiddler2', 'other_public')
tiddler1.text = tiddler2.text = 'ohhai'
store.put(tiddler1)
store.put(tiddler2)
response, content = http.request(
'http://thing.0.0.0.0:8080/search?q=ohhai',
headers={'Accept': 'application/json'},
method='GET')
assert response['status'] == '200', content
info = simplejson.loads(content)
assert len(info) == 1
assert info[0]['title'] == tiddler1.title
response, content = http.request(
'http://other.0.0.0.0:8080/search?q=ohhai',
headers={'Accept': 'application/json'},
method='GET')
assert response['status'] == '200', content
info = simplejson.loads(content)
assert len(info) == 1
assert info[0]['title'] == tiddler2.title
response, content = http.request('http://0.0.0.0:8080/search?q=ohhai',
headers={'Accept': 'application/json'},
method='GET')
assert response['status'] == '200', content
info = simplejson.loads(content)
assert len(info) == 2
Hello, I'm the 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()
from creoleparser import text2html
def render(tiddler, environ):
# XXX this pays no attention to path and it should when
# creating links.
return text2html(tiddler.text)
def init(config_in):
config['wikitext.type_render_map']['text/x-creole'] = 'creolerender'
if __name__ == '__main__':
from tiddlyweb.model.tiddler import Tiddler
tiddler = Tiddler('foo')
tiddler.text = '==Hello==\n[[Hello]]'
print render_wikitext(
tiddler, '', {
'tiddlyweb.config': {
'wikitext.type_render_map': {
'text/x-creole': 'creolerender'
}
}
})
tiddler.type = 'text/x-creole'
print render_wikitext(
tiddler, '', {
'tiddlyweb.config': {
'wikitext.type_render_map': {
def test_drop_privs():
"""
test that privileges are dropped when jsonp is requested
so that we cannot get private data
"""
tiddler = Tiddler('private')
tiddler.bag = 'foo_private'
tiddler.text = 'some text'
store.put(tiddler)
user_cookie = get_auth('foo', 'foobar')
callback = 'callback'
response, _ = http.request(
'http://foo.0.0.0.0:8080/bags/'
'foo_private/tiddlers/private?callback=%s' % callback,
method='GET',
headers={
'Cookie': 'tiddlyweb_user="******"' % user_cookie,
'Accept': 'application/json'
})
assert response['status'] == '401'
response, _ = http.request(
'http://foo.0.0.0.0:8080/recipes/'
'foo_private/tiddlers/private?callback=%s' % callback,
method='GET',
headers={
'Cookie': 'tiddlyweb_user="******"' % user_cookie,
'Accept': 'application/json'
})
assert response['status'] == '401'
response, _ = http.request('http://foo.0.0.0.0:8080/bags/foo_private?'
'callback=%s' % callback,
method='GET',
headers={
'Cookie':
'tiddlyweb_user="******"' % user_cookie,
'Accept': 'application/json'
})
assert response['status'] == '401'
response, _ = http.request('http://foo.0.0.0.0:8080/recipes/foo_private?'
'callback=%s' % callback,
method='GET',
headers={
'Cookie':
'tiddlyweb_user="******"' % user_cookie,
'Accept': 'application/json'
})
assert response['status'] == '401'
response, _ = http.request('http://foo.0.0.0.0:8080/bags/foo_private/'
'tiddlers?callback=%s' % callback,
method='GET',
headers={
'Cookie':
'tiddlyweb_user="******"' % user_cookie,
'Accept': 'application/json'
})
assert response['status'] == '401'
response, _ = http.request('http://foo.0.0.0.0:8080/recipes/foo_private/'
'tiddlers?callback=%s' % callback,
method='GET',
headers={
'Cookie':
'tiddlyweb_user="******"' % user_cookie,
'Accept': 'application/json'
})
assert response['status'] == '401'
response, _ = http.request(
'http://foo.0.0.0.0:8080/bags/'
'foo_private/tiddlers/private',
method='GET',
headers={
'Cookie': 'tiddlyweb_user="******"' % user_cookie,
'Accept': 'application/json'
})
assert response['status'] == '200'
