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