def setup_module(module):
if os.path.exists('store'):
shutil.rmtree('store')
init(config)
module.savedin = sys.stdin
module.store = get_store(config)
module.store.put(Bag('bag1'))
def twimport(args):
"""Import tiddlers, recipes, wikis, binary content: <bag> <URI>"""
bag = args[0]
urls = args[1:]
if not bag or not urls:
raise IndexError('missing args')
import_list(bag, urls, get_store(config))
def setup_module(module):
try:
shutil.rmtree('indexdir')
shutil.rmtree('store')
except:
pass
app = load_app()
def app_fn(): return app
requests_intercept.install()
wsgi_intercept.add_wsgi_intercept('tankt.peermore.com', 8080, app_fn)
store = get_store(config)
test_bag1 = Bag('newtank')
try:
store.delete(test_bag1)
except StoreError:
pass
test_bag1.policy.accept = ['NONE']
store.put(test_bag1)
module.environ = {'tiddlyweb.store': store, 'tiddlyweb.config': config}
module.store = store
module.cookie, module.csrf = establish_user_auth(config, store,
'tankt.peermore.com:8080', 'tester')
def 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 setup_module(module):
module.store = get_store(config)
# cascade to deal with differently named files depending on
# anydbm impelementation
try:
os.unlink('links.db')
except OSError:
pass # not there
module.links_manager = LinksManager()
try:
shutil.rmtree('store')
except:
pass
def app():
return serve.load_app()
httplib2_intercept.install()
wsgi_intercept.add_wsgi_intercept('0.0.0.0', 8080, app)
# for @someone syntax to test correctly we need a corresponding
# recipe
module.store.put(Bag('cdent_public'))
recipe = Recipe('cdent_public')
recipe.set_recipe([('cdent_public', '')])
module.store.put(recipe)
def make_test_env(module):
global SESSION_COUNT
try:
shutil.rmtree('test_instance')
except:
pass
os.system('mysqladmin -f drop tiddlyspacetest create tiddlyspacetest')
if SESSION_COUNT > 1:
del sys.modules['tiddlywebplugins.tiddlyspace.store']
del sys.modules['tiddlywebplugins.mysql2']
del sys.modules['tiddlywebplugins.sqlalchemy2']
import tiddlywebplugins.tiddlyspace.store
import tiddlywebplugins.mysql2
import tiddlywebplugins.sqlalchemy2
clear_hooks(HOOKS)
SESSION_COUNT += 1
db_config = init_config['server_store'][1]['db_config']
db_config = db_config.replace('///tiddlyspace?', '///tiddlyspacetest?')
init_config['server_store'][1]['db_config'] = db_config
init_config['log_level'] = 'DEBUG'
if sys.path[0] != os.getcwd():
sys.path.insert(0, os.getcwd())
spawn('test_instance', init_config, instance_module)
os.symlink('../tiddlywebplugins/templates', 'templates')
from tiddlyweb.web import serve
module.store = get_store(config)
app = serve.load_app()
def app_fn():
return app
module.app_fn = app_fn
def setup_module(module):
try:
shutil.rmtree('indexdir')
shutil.rmtree('store')
except:
pass
app = load_app()
def app_fn(): return app
httplib2_intercept.install()
wsgi_intercept.add_wsgi_intercept('tankt.peermore.com', 8080, app_fn)
store = get_store(config)
test_bag = Bag('editable')
try:
store.delete(test_bag)
except StoreError:
pass
store.put(test_bag)
module.environ = {'tiddlyweb.store': store, 'tiddlyweb.config': config}
module.store = store
module.http = httplib2.Http()
module.csrf = None
def test_cookie_set():
"""
test that we get a cookie relating to the space we are in
"""
store = get_store(config)
space = 'foo'
make_fake_space(store, space)
user = User('foo')
user.set_password('foobar')
store.put(user)
user_cookie = get_auth('foo', 'foobar')
response, _ = http.request(
'http://foo.0.0.0.0:8080/status',
method='GET',
headers={'Cookie': 'tiddlyweb_user="******"' % user_cookie})
assert response['status'] == '200'
time = datetime.now().strftime('%Y%m%d%H')
cookie = 'csrf_token=%s:%s:%s' % (
time, user.usersign,
sha('%s:%s:%s:%s' %
(user.usersign, time, space, config['secret'])).hexdigest())
assert response['set-cookie'] == cookie
def setup_module(module):
try:
shutil.rmtree('store')
except:
pass
config['markdown.wiki_link_base'] = ''
store = get_store(config)
environ['tiddlyweb.store'] = store
store.put(Bag('bag'))
module.store = store
recipe = Recipe('recipe_public')
recipe.set_recipe([('bag', '')])
store.put(recipe)
tiddlerA = Tiddler('tiddler a', 'bag')
tiddlerA.text = 'I am _tiddler_'
store.put(tiddlerA)
tiddlerB = Tiddler('tiddler b')
tiddlerB.text = '''
You wish
{{tiddler a}}
And I wish too.
'''
module.tiddlerB = tiddlerB
def twimport(args):
"""Import tiddlers, recipes, wikis, binary content: <bag> <URI>"""
bag = args[0]
urls = args[1:]
if not bag or not urls:
raise IndexError('missing args')
import_list(bag, urls, get_store(config))
def setup_module(module):
module.store = get_store(config)
module.environ = {"tiddlyweb.config": config, "tiddlyweb.store": module.store}
session = module.store.storage.session
# delete everything
Base.metadata.drop_all()
Base.metadata.create_all()
def init(config):
"""
init function for tiddlywebpages.
Set URLs
define serializers
"""
merge_config(config, twp_config)
#provide a way to allow people to refresh their URLs
config['selector'].add('/tiddlywebpages/refresh', GET=refresh)
#get the store
store = get_store(config)
#set the default config info
BAG_OF_TEMPLATES = config['tw_pages']['template_bag']
if 'config' in config['tw_pages']:
register_config(config, store)
for new_filter in config['tw_pages']['filters']:
_temp = __import__(new_filter, {}, {}, [new_filter])
TW_PAGES_FILTERS.append((new_filter, getattr(_temp, new_filter)))
if 'config' in config['tw_pages']:
register_config(config, store)
register_templates(config, store)
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_no_cookie_sent():
"""
Test no cookie is sent if one is already present
"""
store = get_store(config)
space = 'foo'
make_fake_space(store, space)
user = User('foo')
user.set_password('foobar')
store.put(user)
user_cookie = get_auth('foo', 'foobar')
time = datetime.now().strftime('%Y%m%d%H')
cookie = 'csrf_token=%s:%s:%s' % (
time, user.usersign,
sha('%s:%s:%s:%s' %
(user.usersign, time, space, config['secret'])).hexdigest())
response, _ = http.request(
'http://foo.0.0.0.0:8080/status',
method='GET',
headers={'Cookie': 'tiddlyweb_user="******"; %s' % (user_cookie, cookie)})
cookie = response.get('set-cookie')
if cookie:
assert 'csrf_token' not in cookie
def test_validator_nonce_fail():
"""
test the validator directly
ensure that it fails when the nonce doesn't match
"""
store = get_store(config)
nonce = 'dwaoiju277218ywdhdnakas72'
username = '******'
spacename = 'foo'
secret = '12345'
timestamp = datetime.now().strftime('%Y%m%d%H')
environ = {
'tiddlyweb.usersign': {
'name': username
},
'tiddlyweb.config': {
'secret': secret,
'server_host': {
'host': '0.0.0.0',
'port': '8080'
}
},
'HTTP_HOST': 'foo.0.0.0.0:8080'
}
make_fake_space(store, spacename)
try:
csrf = CSRFProtector({})
result = csrf.check_csrf(environ, nonce)
raise AssertionError('check_csrf succeeded when nonce didn\'t match')
except InvalidNonceError, exc:
assert exc.message == BAD_MATCH_MESSAGE
def setup_module(module):
module.TMPDIR = tempfile.mkdtemp()
_initialize_app(TMPDIR)
module.ADMIN_COOKIE = make_cookie('tiddlyweb_user', 'admin',
mac_key=CONFIG['secret'])
module.STORE = get_store(CONFIG)
# register admin user
data = {
'username': '******',
'password': '******',
'password_confirmation': 'secret'
}
response, content = _req('POST', '/register', urlencode(data),
headers={ 'Content-Type': 'application/x-www-form-urlencoded' })
bag = Bag('alpha')
bag.policy = Policy(read=['admin'], write=['admin'], create=['admin'],
delete=['admin'], manage=['admin'])
STORE.put(bag)
bag = Bag('bravo')
STORE.put(bag)
bag = Bag('charlie')
bag.policy = Policy(read=['nobody'], write=['nobody'], create=['nobody'],
delete=['nobody'], manage=['nobody'])
STORE.put(bag)
tiddler = Tiddler('index', 'bravo')
tiddler.text = 'lorem ipsum\ndolor *sit* amet'
tiddler.type = 'text/x-markdown'
STORE.put(tiddler)
def setup_module(module):
try:
shutil.rmtree('indexdir')
shutil.rmtree('store')
except:
pass
app = load_app()
def app_fn():
return app
requests_intercept.install()
wsgi_intercept.add_wsgi_intercept('tankt.peermore.com', 8080, app_fn)
store = get_store(config)
test_bag1 = Bag('newtank')
try:
store.delete(test_bag1)
except StoreError:
pass
test_bag1.policy.accept = ['NONE']
store.put(test_bag1)
module.environ = {'tiddlyweb.store': store, 'tiddlyweb.config': config}
module.store = store
module.cookie, module.csrf = establish_user_auth(
config, store, 'tankt.peermore.com:8080', 'tester')
def test_validator_nonce_success():
"""
test the validator directly
ensure that it succeeds when the nonce passed in is correct
"""
store = get_store(config)
username = '******'
spacename = 'foo'
secret = '12345'
timestamp = datetime.now().strftime('%Y%m%d%H')
nonce = '%s:%s:%s' % (
timestamp, username,
sha('%s:%s:%s:%s' %
(username, timestamp, spacename, secret)).hexdigest())
environ = {
'tiddlyweb.usersign': {
'name': username
},
'tiddlyweb.config': {
'secret': secret,
'server_host': {
'host': '0.0.0.0',
'port': '8080'
}
},
'HTTP_HOST': 'foo.0.0.0.0:8080'
}
make_fake_space(store, spacename)
csrf = CSRFProtector({})
result = csrf.check_csrf(environ, nonce)
assert result == True
def test_cookie_set():
"""
test that we get a cookie relating to the space we are in
"""
store = get_store(config)
space = 'foo'
make_fake_space(store, space)
user = User('foo')
user.set_password('foobar')
store.put(user)
user_cookie = get_auth('foo', 'foobar')
response, content = http.request('http://foo.0.0.0.0:8080/status',
method='GET',
headers={
'Cookie': 'tiddlyweb_user="******"' % user_cookie
})
assert response['status'] == '200', content
time = datetime.now().strftime('%Y%m%d%H')
cookie = 'csrf_token=%s:%s:%s' % (time, user.usersign,
sha('%s:%s:%s:%s' % (user.usersign,
time, space, config['secret'])).hexdigest())
assert response['set-cookie'] == cookie
def _init_store(self, struct):
"""
creates basic store structure with bags, recipes and users
(no support for user passwords for security reasons)
"""
store = get_store(self.init_config)
bags = struct.get("bags", {})
for name, data in bags.items():
desc = data.get("desc")
bag = Bag(name, desc=desc)
constraints = data.get("policy", {})
_set_policy(bag, constraints)
store.put(bag)
recipes = struct.get("recipes", {})
for name, data in recipes.items(): # TODO: DRY
desc = data.get("desc")
recipe = Recipe(name, desc=desc)
recipe.set_recipe(data["recipe"])
constraints = data.get("policy", {})
_set_policy(recipe, constraints)
store.put(recipe)
users = struct.get("users", {})
for name, data in users.items():
note = data.get("note")
user = User(name, note=note)
password = data.get("_password")
if password:
user.set_password(password)
for role in data.get("roles", []):
user.add_role(role)
store.put(user)
def setup_module(module):
reset_textstore()
module.store = get_store(config)
module.environ = {
'tiddlyweb.config': config,
'tiddlyweb.store': module.store
}
def tiddler(context, *args):
base = context.var_get_text("$BASE_URL")
path =""
if not context.environ:
return ""
store = get_store(config)
logging.debug("in tiddler macro")
try:
environ = context.environ
except NoAttributeError:
return _throw_error()
try:
tid = context.tiddler
except NoAttributeError:
return ""
if tid.recipe:
tids = control.get_tiddlers_from_recipe(store.get(Recipe(tid.recipe)))
elif tid.bag:
bag = store.get(Bag(tid.bag))
tids = bag.list_tiddlers()
else:
return ""
try:
tiddler_requested = args[0].text
for tiddler in tids:
if tiddler.title == tiddler_requested:
tiddler = store.get(tiddler)
except Exception:
tiddler = context.tiddler
if tiddler:
text = wikitext_to_wikklyhtml(base,path, tiddler.text, environ,tiddler=context.tiddler)
return "%s"%text
else:
return ""#no tiddler with that name
def wreindex(args):
"""Rebuild the entire whoosh index."""
try:
prefix = args[0]
except IndexError:
prefix = None
store = get_store(config)
schema = config.get('wsearch.schema',
SEARCH_DEFAULTS['wsearch.schema'])
if __name__ in config.get('beanstalk.listeners', []):
_reindex_async(config)
else:
for bag in store.list_bags():
bag = store.get(bag)
writer = get_writer(config)
if writer:
try:
try:
tiddlers = bag.get_tiddlers()
except AttributeError:
tiddlers = store.list_bag_tiddlers(bag)
for tiddler in tiddlers:
if prefix and not tiddler.title.startswith(prefix):
continue
tiddler = store.get(tiddler)
index_tiddler(tiddler, schema, writer)
writer.commit()
except:
LOGGER.debug('whoosher: exception while indexing: %s',
format_exc())
writer.cancel()
else:
LOGGER.debug('whoosher: unable to get writer '
'(locked) for %s', bag.name)
def delete_subscription(email):
"""
remove somebody from a particular subscription
"""
store = get_store(config)
recipe = determine_bag(email['to'])
fromAddress = email['from']
subscription_bag = get_subscriptions_bag(store)
try:
subscribers_tiddler = store.get(Tiddler('bags/%s/tiddlers' % recipe, subscription_bag))
subscriber_emails = subscribers_tiddler.text.splitlines()
try:
subscriber_emails.remove(fromAddress)
except ValueError:
pass
subscribers_tiddler.text = '\n'.join(subscriber_emails)
store.put(subscribers_tiddler)
except NoTiddlerError:
pass
return {'from': email['to'],
'to': email['from'],
'subject': 'You have been unsubscribed from %s' % recipe,
'body': 'Harry the dog is currently whining in sadness.'
}
def make_subscription(email):
"""
add somebody to a subscription
"""
store = get_store(config)
recipe = determine_bag(email['to'])
fromAddress = email['from']
subscription_bag = get_subscriptions_bag(store)
subscribers_tiddler = Tiddler('bags/%s/tiddlers' % recipe, subscription_bag)
try:
subscribers_tiddler = store.get(subscribers_tiddler)
subscriber_emails = subscribers_tiddler.text.splitlines()
if fromAddress not in subscriber_emails:
subscriber_emails.append(fromAddress)
subscribers_tiddler.text = '\n'.join(subscriber_emails)
store.put(subscribers_tiddler)
except NoTiddlerError:
subscribers_tiddler.text = fromAddress
store.put(subscribers_tiddler)
return {'from': email['to'],
'to': email['from'],
'subject': 'You have subscribed to %s' % recipe,
'body': 'You will now receive daily digests. To unsubscribe please email unsubscribe@%s'
}
def test_validator_nonce_fail():
"""
test the validator directly
ensure that it fails when the nonce doesn't match
"""
store = get_store(config)
nonce = 'dwaoiju277218ywdhdnakas72'
username = '******'
spacename = 'foo'
secret = '12345'
timestamp = datetime.now().strftime('%Y%m%d%H')
environ = {
'tiddlyweb.usersign': {'name': username},
'tiddlyweb.config': {
'secret': secret,
'server_host': {
'host': '0.0.0.0',
'port': '8080'
}
},
'HTTP_HOST': 'foo.0.0.0.0:8080'
}
make_fake_space(store, spacename)
try:
csrf = CSRFProtector({})
result = csrf.check_csrf(environ, nonce)
raise AssertionError('check_csrf succeeded when nonce didn\'t match')
except InvalidNonceError, exc:
assert exc.message == BAD_MATCH_MESSAGE
def test_validator_nonce_success():
"""
test the validator directly
ensure that it succeeds when the nonce passed in is correct
"""
store = get_store(config)
username = '******'
spacename = 'foo'
secret = '12345'
timestamp = datetime.now().strftime('%Y%m%d%H')
nonce = '%s:%s:%s' % (timestamp, username,
sha('%s:%s:%s:%s' % (username, timestamp, spacename, secret)).
hexdigest())
environ = {
'tiddlyweb.usersign': {'name': username},
'tiddlyweb.config': {
'secret': secret,
'server_host': {
'host': '0.0.0.0',
'port': '8080'
}
},
'HTTP_HOST': 'foo.0.0.0.0:8080'
}
make_fake_space(store, spacename)
csrf = CSRFProtector({})
result = csrf.check_csrf(environ, nonce)
assert result == True
def test_no_cookie_sent():
"""
Test no cookie is sent if one is already present
"""
store = get_store(config)
space = 'foo'
make_fake_space(store, space)
user = User('foo')
user.set_password('foobar')
store.put(user)
user_cookie = get_auth('foo', 'foobar')
time = datetime.now().strftime('%Y%m%d%H')
cookie = 'csrf_token=%s:%s:%s' % (time, user.usersign,
sha('%s:%s:%s:%s' % (user.usersign,
time, space, config['secret'])).hexdigest())
response, _ = http.request('http://foo.0.0.0.0:8080/status',
method='GET',
headers={
'Cookie': 'tiddlyweb_user="******"; %s' % (user_cookie, cookie)
})
cookie = response.get('set-cookie')
if cookie:
assert 'csrf_token' not in cookie
def retrieve_from_store(email):
"""
get the tiddler requested by the email from the store
and return it as an email
"""
store = get_store(config)
tiddler_title = clean_subject(email["subject"])
tiddler = Tiddler(tiddler_title)
bag = determine_bag(email["to"])
tiddler.bag = bag
try:
tiddler = store.get(tiddler)
response_text = tiddler.text
except NoTiddlerError:
# Tiddler not found. Return a list of all tiddlers
bag = Bag(bag)
bag = store.get(bag)
response_text = "The following tiddlers are in %s:\n" % email["to"].split("@")[1]
tiddlers = bag.gen_tiddlers()
tiddlers = [tiddler for tiddler in tiddlers]
response_text += "\n".join([tiddler.title for tiddler in tiddlers])
response_email = {"from": email["to"], "to": email["from"], "subject": tiddler.title, "body": response_text}
return response_email
def determine_entries(environ):
"""
returns descendant resources based on the WSGI environment
"""
candidates = { # XXX: hard-coded; ideally descendants should be determined via HATEOAS-y clues
"[/]": lambda *args: [Collection("/bags"), Collection("/recipes")],
"/bags[.{format}]": _bags,
"/recipes[.{format}]": _recipes,
"/bags/{bag_name:segment}/tiddlers[.{format}]": _tiddlers
}
current_uri = environ["SCRIPT_NAME"]
config = environ["tiddlyweb.config"]
store = get_store(config)
router = Router(mapfile=config["urls_map"], prefix=config["server_prefix"]) # XXX: does not support extensions
for regex, supported_methods in router.mappings:
if regex.search(current_uri): # matching route
pattern = router.routes[regex]
descendants = candidates[pattern]
routing_args = environ["wsgiorg.routing_args"]
descendants = descendants(store, *routing_args[0], **routing_args[1])
break
return chain([Collection(current_uri)], descendants)
def setup_module(module):
"""
clean up the store, establish a registered client
"""
clean_store()
module.store = get_store(config)
environ = {'tiddlyweb.config': config, 'tiddlyweb.store': module.store}
ensure_bags(config)
# make an application and store that info
app = create(name='testapp', owner='appowner1',
app_url='http://our_test_domain:8001',
callback_url='http://our_test_domain:8001/_oauth/callback')
client_id = app.title
client_secret = app.fields['client_secret']
store_app(environ, app)
config['oauth.servers']['testserver']['client_id'] = client_id
config['oauth.servers']['testserver']['client_secret'] = client_secret
module.client_id = client_id
initialize_app(config)
module.http = Http()
# we need a user who is going to use the client app
user = User('cdent')
user.set_password('cowpig')
module.store.put(user)
def test_cookie_set():
"""
test that we get a cookie relating to the space we are in
"""
store = get_store(config)
hostname = "foo.0.0.0.0:8080"
user = User(u"f\u00F6o")
user.set_password("foobar")
store.put(user)
user_cookie = get_auth(u"f\u00F6o", "foobar")
response, content = http.request(
"http://foo.0.0.0.0:8080/", method="GET", headers={"Cookie": 'tiddlyweb_user="******"' % user_cookie}
)
assert response["status"] == "200", content
time = datetime.utcnow().strftime("%Y%m%d%H")
cookie = "csrf_token=%s:%s:%s" % (
time,
user.usersign,
sha("%s:%s:%s:%s" % (user.usersign, time, hostname, config["secret"])).hexdigest(),
)
assert response["set-cookie"] == quote(cookie.encode("utf-8"), safe=".!~*'():=")
def _reindex_async(config):
from tiddlywebplugins.dispatcher.listener import (DEFAULT_BEANSTALK_HOST,
DEFAULT_BEANSTALK_PORT, BODY_SEPARATOR)
import beanstalkc
beanstalk_host = config.get('beanstalk.host', DEFAULT_BEANSTALK_HOST)
beanstalk_port = config.get('beanstalk.port', DEFAULT_BEANSTALK_PORT)
beanstalk = beanstalkc.Connection(host=beanstalk_host,
port=beanstalk_port)
username = '******'
beanstalk.use('index')
store = get_store(config)
for bag in store.list_bags():
bag = store.get(bag)
try:
tiddlers = bag.get_tiddlers()
except AttributeError:
tiddlers = store.list_bag_tiddlers(bag)
for tiddler in tiddlers:
tiddler = store.get(tiddler)
data = BODY_SEPARATOR.join([username, tiddler.bag, tiddler.title,
str(tiddler.revision)])
try:
beanstalk.put(data.encode('UTF-8'))
except beanstalkc.SocketError as exc:
LOGGER.error('unable to write to beanstalkd for %s:%s: %s',
tiddler.bag, tiddler.title, exc)
def setup_store():
"""
initialise a blank store, and fill it with some data
"""
store = get_store(config)
for bag in BAGS:
bag = Bag(bag)
try:
store.delete(bag)
except NoBagError:
pass
store.put(bag)
for recipe, contents in RECIPES.iteritems():
recipe = Recipe(recipe)
try:
store.delete(recipe)
except NoRecipeError:
pass
recipe.set_recipe(contents)
store.put(recipe)
return store
def setup_module(module):
try:
shutil.rmtree('indexdir')
shutil.rmtree('store')
except:
pass
app = load_app()
def app_fn():
return app
httplib2_intercept.install()
wsgi_intercept.add_wsgi_intercept('tankt.peermore.com', 8080, app_fn)
store = get_store(config)
test_bag = Bag('editable')
try:
store.delete(test_bag)
except StoreError:
pass
store.put(test_bag)
module.environ = {'tiddlyweb.store': store, 'tiddlyweb.config': config}
module.store = store
module.http = httplib2.Http()
module.csrf = None
def init(config):
"""
init function for tiddlywebpages.
Set URLs
define serializers
"""
merge_config(config, twp_config)
# provide a way to allow people to refresh their URLs
config["selector"].add("/tiddlywebpages/refresh", GET=refresh)
# get the store
store = get_store(config)
# set the default config info
BAG_OF_TEMPLATES = config["tw_pages"]["template_bag"]
if "config" in config["tw_pages"]:
register_config(config, store)
for new_filter in config["tw_pages"]["filters"]:
_temp = __import__(new_filter, {}, {}, [new_filter])
TW_PAGES_FILTERS.append((new_filter, getattr(_temp, new_filter)))
if "config" in config["tw_pages"]:
register_config(config, store)
register_templates(config, store)
def make_test_env(module, hsearch=False):
"""
If hsearch is False, don't bother updating the whoosh index
for this test instance. We do this by removing the store HOOK
used by whoosh.
"""
global SESSION_COUNT
# bump up a level if we're already in the test instance
if os.getcwd().endswith('test_instance'):
os.chdir('..')
try:
shutil.rmtree('test_instance')
except:
pass
os.system(
'echo "drop database if exists tiddlyspacetest; create database tiddlyspacetest character set = utf8mb4 collate = utf8mb4_bin;" | mysql'
)
if SESSION_COUNT > 1:
del sys.modules['tiddlywebplugins.tiddlyspace.store']
del sys.modules['tiddlywebplugins.mysql3']
del sys.modules['tiddlywebplugins.sqlalchemy3']
import tiddlywebplugins.tiddlyspace.store
import tiddlywebplugins.mysql3
import tiddlywebplugins.sqlalchemy3
tiddlywebplugins.mysql3.Session.remove()
clear_hooks(HOOKS)
SESSION_COUNT += 1
db_config = init_config['server_store'][1]['db_config']
db_config = db_config.replace('///tiddlyspace?', '///tiddlyspacetest?')
init_config['server_store'][1]['db_config'] = db_config
init_config['log_level'] = 'DEBUG'
if sys.path[0] != os.getcwd():
sys.path.insert(0, os.getcwd())
spawn('test_instance', init_config, instance_module)
os.chdir('test_instance')
os.symlink('../tiddlywebplugins/templates', 'templates')
os.symlink('../tiddlywebplugins', 'tiddlywebplugins')
from tiddlyweb.web import serve
module.store = get_store(init_config)
app = serve.load_app()
if not hsearch:
from tiddlywebplugins.whoosher import _tiddler_change_handler
try:
HOOKS['tiddler']['put'].remove(_tiddler_change_handler)
HOOKS['tiddler']['delete'].remove(_tiddler_change_handler)
except ValueError:
pass
def app_fn():
return app
module.app_fn = app_fn
def todos(args):
"""List the todos."""
store = get_store(global_config)
bag = Bag('do')
bag = store.get(bag)
titles = [(tiddler.modified, tiddler.title) for tiddler in
control.filter_tiddlers_from_bag(bag, 'sort=modified')]
print '\n'.join(['%s: %s' % title for title in titles])
def fixbags():
store = get_store(config)
bags = store.list_bags()
for bag in bags:
bag = store.get(bag)
bag.policy.read = []
store.put(bag)
def setup_store(config):
global store
store = get_store(config)
bag = Bag("tiddlyvoting")
try:
store.get(bag)
except NoBagError:
store.put(bag)
def setup_module(module):
try:
shutil.rmtree('store')
shutil.rmtree('binarystore')
except (OSError, IOError):
pass
module.store = get_store(config)
def _write_new_tiddler(source_tiddler, target_tiddler=None):
# reset the source tiddler as the target tiddler (so its contents
# are saved
source_tiddler.revision = 0
if target_tiddler:
source_tiddler.title = target_tiddler.title
source_tiddler.bag = target_tiddler.bag
store = get_store(config)
store.put(source_tiddler)
def get_atom_config(self, resource_type, resource_name):
store = get_store(config)
atomconfig = False
if resource_type == 'bag':
try:
atomconfig = store.get(
Tiddler(self.ATOM_CONFIG_TITLE, resource_name))
except NoTiddlerError, NoBagError:
pass
def setup_module(module):
module.store = get_store(config)
module.environ = {
'tiddlyweb.config': config,
'tiddlyweb.store': module.store
}
session = module.store.storage.session
# delete everything
Base.metadata.drop_all()
Base.metadata.create_all()
def test_post_data_multipart_form():
"""
test that a form POST requires a nonce
test using multipart/form-data
"""
store = get_store(config)
space = 'foo'
make_fake_space(store, space)
user = User('foo')
user.set_password('foobar')
store.put(user)
timestamp = datetime.now().strftime('%Y%m%d%H')
secret = config['secret']
nonce = '%s:%s:%s' % (
timestamp, user.usersign,
sha('%s:%s:%s:%s' %
(user.usersign, timestamp, space, secret)).hexdigest())
user_cookie = get_auth('foo', 'foobar')
csrf_token = 'csrf_token=%s' % nonce
data = '''---------------------------168072824752491622650073
Content-Disposition: form-data; name="title"
foobar
---------------------------168072824752491622650073
Content-Disposition: form-data; name="text"
Hello World
---------------------------168072824752491622650073--'''
#test success
uri = 'http://foo.0.0.0.0:8080/bags/foo_public/tiddlers?%s' % csrf_token
response, content = http.request(uri,
method='POST',
headers={
'Content-Type': 'multipart/form-data; ' \
'boundary=---------------------------168072824752491622650073',
'Cookie': 'tiddlyweb_user="******"' % user_cookie,
'Content-Length': '390'
},
body=data)
print content
assert response['status'] == '204'
#test failure
response, _ = http.request('http://foo.0.0.0.0:8080/bags/foo_public/tiddlers',
method='POST',
headers={
'Content-Type': 'multipart/form-data; ' \
'boundary=---------------------------168072824752491622650073',
'Cookie': 'tiddlyweb_user="******"' % user_cookie,
'Content-Length': '267'
},
body=data)
assert response['status'] == '400'
def setup_module(module):
try:
shutil.rmtree('store')
except:
pass
module.store = get_store(config)
init(config)
base_recipe = Recipe('hi')
base_recipe.set_recipe([('system', ''), ('stuff', 'select=title:monkey'),
('things', '')])
module.store.put(base_recipe)
sys.exit = boring_exit
def adduserpolicy(username):
store = get_store(config)
bags = store.list_bags()
for bag in bags:
bag = store.get(bag)
read_policy = bag.policy.read
if username not in read_policy:
print 'adding %s to %s' % (username, bag.name)
read_policy.append(username)
store.put(bag)
def addproject(args):
"""make a project space. <project_name>"""
if len(args) != 1:
print >> sys.stderr, ('usage: twanager addproject <project_name>')
#replace PROJECT_NAME with the actual name of the project
this_project = PROJECT.replace('PROJECT_NAME', args[0])
this_project = json.loads(this_project)
#create the space
project_space = Space({'tiddlyweb.store': get_store(config)})
project_space.create_space(this_project)
def _tiddler_written_handler(storage, tiddler):
schema = storage.environ['tiddlyweb.config'].get(
'wsearch.schema', SEARCH_DEFAULTS['wsearch.schema'])
writer = get_writer(storage.environ['tiddlyweb.config'])
try:
store = storage.environ.get(
'tiddlyweb.store', get_store(storage.environ['tiddlyweb.config']))
temp_tiddler = store.get(Tiddler(tiddler.title, tiddler.bag))
index_tiddler(tiddler, schema, writer)
except NoTiddlerError:
delete_tiddler(tiddler, writer)
writer.commit()
def test_validator_no_nonce():
"""
test the validator directly
ensure that it fails when the nonce is not present
"""
store = get_store(config)
try:
csrf = CSRFProtector({})
result = csrf.check_csrf({}, None)
raise AssertionError(
'check_csrf succeeded when no csrf_token supplied')
except InvalidNonceError, exc:
assert exc.message == 'No csrf_token supplied'
def _act(self, job):
if not self.STORE:
self.STORE = get_store(self.config)
info = self._unpack(job)
tiddler = Tiddler(info['tiddler'], info['bag'])
try:
self.STORE.get(tiddler)
except StoreError:
return None # Tiddler's not there, no need to notify
user = tiddler.modifier
if self._user_has_profile(user):
self._send_ping(user)
def setup_module(module):
clean_store()
module.store = get_store(config)
module.environ = {
'tiddlyweb.config': config,
'tiddlyweb.store': module.store
}
ensure_bags(config)
initialize_app(config)
module.http = Http()
user = User('cdent')
user.set_password('cowpig')
module.store.put(user)
def setup_module(module):
for dir in ('store', 'indexdir'):
try:
shutil.rmtree(dir)
except: # heavy!
pass
init(config)
store = get_store(config)
store.put(Bag('bagone'))
store.put(Bag('bagtwo'))
module.store = store
def populate_store():
store = get_store(config)
for bag_name in ["alpha", "bravo"]:
bag = Bag(bag_name)
store.put(bag)
for title in ["foo", "bar"]:
tiddler = Tiddler(title)
tiddler.bag = bag.name
store.put(tiddler)
for recipe_name in ["omega"]:
recipe = Recipe(recipe_name)
store.put(recipe)
def setup_module(module):
try:
shutil.rmtree('indexdir')
shutil.rmtree('store')
except:
pass
init(config)
module.store = get_store(config)
module.environ = {
'tiddlyweb.config': config,
'tiddlyweb.store': module.store,
'tiddlyweb.usersign': {
'name': 'cdent',
'roles': ['MEMBER']
}
}
def wreindex(args):
"""Rebuild the entire whoosh index."""
try:
prefix = args[0]
except IndexError:
prefix = None
store = get_store(config)
writer = get_writer(config)
schema = config.get('wsearch.schema', SEARCH_DEFAULTS['wsearch.schema'])
for bag in store.list_bags():
bag = store.get(bag)
for tiddler in bag.list_tiddlers():
if prefix and not tiddler.title.startswith(prefix):
continue
tiddler = store.get(tiddler)
index_tiddler(tiddler, schema, writer)
writer.commit()
def _act(self, job):
"""
Do the action of sending the ping when a job (a tiddler)
is received from the queue.
"""
if not self.STORE:
self.STORE = get_store(self.config)
info = self._unpack(job)
tiddler = Tiddler(info['tiddler'], info['bag'])
try:
self.STORE.get(tiddler)
except StoreError:
return None # Tiddler's not there, no need to notify
user = tiddler.modifier
if self._user_has_profile(user):
self._send_ping(user)
