test/memorydb.py

   1 # $Id: test_memorydb.py,v 1.4 2004-11-03 01:34:21 richard Exp $
   2 '''Implement an in-memory hyperdb for testing purposes.
   3 '''
   4
   5 import shutil
   6
   7 from roundup import hyperdb
   8 from roundup import roundupdb
   9 from roundup import security
  10 from roundup import password
  11 from roundup import configuration
  12 from roundup.backends import back_anydbm
  13 from roundup.backends import indexer_dbm
  14 from roundup.backends import indexer_common
  15 from roundup.hyperdb import *
  16
  17 def new_config():
  18     config = configuration.CoreConfig()
  19     config.DATABASE = "db"
  20     #config.logging = MockNull()
  21     # these TRACKER_WEB and MAIL_DOMAIN values are used in mailgw tests
  22     config.MAIL_DOMAIN = "your.tracker.email.domain.example"
  23     config.TRACKER_WEB = "http://tracker.example/cgi-bin/roundup.cgi/bugs/"
  24     return config
  25
  26 def create(journaltag, create=True):
  27     db = Database(new_config(), journaltag)
  28
  29     # load standard schema
  30     schema = os.path.join(os.path.dirname(__file__),
  31         '../share/roundup/templates/classic/schema.py')
  32     vars = dict(globals())
  33     vars['db'] = db
  34     execfile(schema, vars)
  35     initial_data = os.path.join(os.path.dirname(__file__),
  36         '../share/roundup/templates/classic/initial_data.py')
  37     vars = dict(db=db, admin_email='admin@test.com',
  38         adminpw=password.Password('sekrit'))
  39     execfile(initial_data, vars)
  40
  41     # load standard detectors
  42     dirname = os.path.join(os.path.dirname(__file__),
  43         '../share/roundup/templates/classic/detectors')
  44     for fn in os.listdir(dirname):
  45         if not fn.endswith('.py'): continue
  46         vars = {}
  47         execfile(os.path.join(dirname, fn), vars)
  48         vars['init'](db)
  49
  50     '''
  51     status = Class(db, "status", name=String())
  52     status.setkey("name")
  53     priority = Class(db, "priority", name=String(), order=String())
  54     priority.setkey("name")
  55     keyword = Class(db, "keyword", name=String(), order=String())
  56     keyword.setkey("name")
  57     user = Class(db, "user", username=String(), password=Password(),
  58         assignable=Boolean(), age=Number(), roles=String(), address=String(),
  59         supervisor=Link('user'),realname=String(),alternate_addresses=String())
  60     user.setkey("username")
  61     file = FileClass(db, "file", name=String(), type=String(),
  62         comment=String(indexme="yes"), fooz=Password())
  63     file_nidx = FileClass(db, "file_nidx", content=String(indexme='no'))
  64     issue = IssueClass(db, "issue", title=String(indexme="yes"),
  65         status=Link("status"), nosy=Multilink("user"), deadline=Date(),
  66         foo=Interval(), files=Multilink("file"), assignedto=Link('user'),
  67         priority=Link('priority'), spam=Multilink('msg'),
  68         feedback=Link('msg'))
  69     stuff = Class(db, "stuff", stuff=String())
  70     session = Class(db, 'session', title=String())
  71     msg = FileClass(db, "msg", date=Date(),
  72                            author=Link("user", do_journal='no'),
  73                            files=Multilink('file'), inreplyto=String(),
  74                            messageid=String(), summary=String(),
  75                            content=String(),
  76                            recipients=Multilink("user", do_journal='no')
  77                            )
  78     '''
  79     if create:
  80         db.user.create(username="fred", roles='User',
  81             password=password.Password('sekrit'), address='fred@example.com')
  82
  83     db.security.addPermissionToRole('User', 'Email Access')
  84     '''
  85     db.security.addPermission(name='Register', klass='user')
  86     db.security.addPermissionToRole('User', 'Web Access')
  87     db.security.addPermissionToRole('Anonymous', 'Email Access')
  88     db.security.addPermissionToRole('Anonymous', 'Register', 'user')
  89     for cl in 'issue', 'file', 'msg', 'keyword':
  90         db.security.addPermissionToRole('User', 'View', cl)
  91         db.security.addPermissionToRole('User', 'Edit', cl)
  92         db.security.addPermissionToRole('User', 'Create', cl)
  93     for cl in 'priority', 'status':
  94         db.security.addPermissionToRole('User', 'View', cl)
  95     '''
  96     return db
  97
  98 class cldb(dict):
  99     def close(self):
 100         pass
 101
 102 class BasicDatabase(dict):
 103     ''' Provide a nice encapsulation of an anydbm store.
 104
 105         Keys are id strings, values are automatically marshalled data.
 106     '''
 107     def __getitem__(self, key):
 108         if key not in self:
 109             d = self[key] = {}
 110             return d
 111         return super(BasicDatabase, self).__getitem__(key)
 112     def exists(self, infoid):
 113         return infoid in self
 114     def get(self, infoid, value, default=None):
 115         return self[infoid].get(value, default)
 116     def getall(self, infoid):
 117         return self[infoid]
 118     def set(self, infoid, **newvalues):
 119         self[infoid].update(newvalues)
 120     def list(self):
 121         return self.keys()
 122     def destroy(self, infoid):
 123         del self[infoid]
 124     def commit(self):
 125         pass
 126     def close(self):
 127         pass
 128     def updateTimestamp(self, sessid):
 129         pass
 130     def clean(self):
 131         pass
 132
 133 class Sessions(BasicDatabase):
 134     name = 'sessions'
 135
 136 class OneTimeKeys(BasicDatabase):
 137     name = 'otks'
 138
 139 class Indexer(indexer_dbm.Indexer):
 140     def __init__(self, db):
 141         indexer_common.Indexer.__init__(self, db)
 142         self.reindex = 0
 143         self.quiet = 9
 144         self.changed = 0
 145
 146     def load_index(self, reload=0, wordlist=None):
 147         # Unless reload is indicated, do not load twice
 148         if self.index_loaded() and not reload:
 149             return 0
 150         self.words = {}
 151         self.files = {'_TOP':(0,None)}
 152         self.fileids = {}
 153         self.changed = 0
 154
 155     def save_index(self):
 156         pass
 157
 158 class Database(hyperdb.Database, roundupdb.Database):
 159     """A database for storing records containing flexible data types.
 160
 161     Transaction stuff TODO:
 162
 163     - check the timestamp of the class file and nuke the cache if it's
 164       modified. Do some sort of conflict checking on the dirty stuff.
 165     - perhaps detect write collisions (related to above)?
 166     """
 167     def __init__(self, config, journaltag=None):
 168         self.config, self.journaltag = config, journaltag
 169         self.classes = {}
 170         self.items = {}
 171         self.ids = {}
 172         self.journals = {}
 173         self.files = {}
 174         self.security = security.Security(self)
 175         self.stats = {'cache_hits': 0, 'cache_misses': 0, 'get_items': 0,
 176             'filtering': 0}
 177         self.sessions = Sessions()
 178         self.otks = OneTimeKeys()
 179         self.indexer = Indexer(self)
 180
 181
 182     def filename(self, classname, nodeid, property=None, create=0):
 183         shutil.copyfile(__file__, __file__+'.dummy')
 184         return __file__+'.dummy'
 185
 186     def post_init(self):
 187         pass
 188
 189     def refresh_database(self):
 190         pass
 191
 192     def getSessionManager(self):
 193         return self.sessions
 194
 195     def getOTKManager(self):
 196         return self.otks
 197
 198     def reindex(self, classname=None, show_progress=False):
 199         pass
 200
 201     def __repr__(self):
 202         return '<memorydb instance at %x>'%id(self)
 203
 204     def storefile(self, classname, nodeid, property, content):
 205         self.files[classname, nodeid, property] = content
 206
 207     def getfile(self, classname, nodeid, property):
 208         return self.files[classname, nodeid, property]
 209
 210     def numfiles(self):
 211         return len(self.files)
 212
 213     #
 214     # Classes
 215     #
 216     def __getattr__(self, classname):
 217         """A convenient way of calling self.getclass(classname)."""
 218         if self.classes.has_key(classname):
 219             return self.classes[classname]
 220         raise AttributeError, classname
 221
 222     def addclass(self, cl):
 223         cn = cl.classname
 224         if self.classes.has_key(cn):
 225             raise ValueError, cn
 226         self.classes[cn] = cl
 227         self.items[cn] = cldb()
 228         self.ids[cn] = 0
 229
 230         # add default Edit and View permissions
 231         self.security.addPermission(name="Create", klass=cn,
 232             description="User is allowed to create "+cn)
 233         self.security.addPermission(name="Edit", klass=cn,
 234             description="User is allowed to edit "+cn)
 235         self.security.addPermission(name="View", klass=cn,
 236             description="User is allowed to access "+cn)
 237
 238     def getclasses(self):
 239         """Return a list of the names of all existing classes."""
 240         l = self.classes.keys()
 241         l.sort()
 242         return l
 243
 244     def getclass(self, classname):
 245         """Get the Class object representing a particular class.
 246
 247         If 'classname' is not a valid class name, a KeyError is raised.
 248         """
 249         try:
 250             return self.classes[classname]
 251         except KeyError:
 252             raise KeyError, 'There is no class called "%s"'%classname
 253
 254     #
 255     # Class DBs
 256     #
 257     def clear(self):
 258         self.items = {}
 259
 260     def getclassdb(self, classname):
 261         """ grab a connection to the class db that will be used for
 262             multiple actions
 263         """
 264         return self.items[classname]
 265
 266     #
 267     # Node IDs
 268     #
 269     def newid(self, classname):
 270         self.ids[classname] += 1
 271         return str(self.ids[classname])
 272
 273     #
 274     # Nodes
 275     #
 276     def addnode(self, classname, nodeid, node):
 277         self.getclassdb(classname)[nodeid] = node
 278
 279     def setnode(self, classname, nodeid, node):
 280         self.getclassdb(classname)[nodeid] = node
 281
 282     def getnode(self, classname, nodeid, db=None):
 283         if db is not None:
 284             return db[nodeid]
 285         return self.getclassdb(classname)[nodeid]
 286
 287     def destroynode(self, classname, nodeid):
 288         del self.getclassdb(classname)[nodeid]
 289
 290     def hasnode(self, classname, nodeid):
 291         return nodeid in self.getclassdb(classname)
 292
 293     def countnodes(self, classname, db=None):
 294         return len(self.getclassdb(classname))
 295
 296     #
 297     # Journal
 298     #
 299     def addjournal(self, classname, nodeid, action, params, creator=None,
 300             creation=None):
 301         if creator is None:
 302             creator = self.getuid()
 303         if creation is None:
 304             creation = date.Date()
 305         self.journals.setdefault(classname, {}).setdefault(nodeid,
 306             []).append((nodeid, creation, creator, action, params))
 307
 308     def setjournal(self, classname, nodeid, journal):
 309         self.journals.setdefault(classname, {})[nodeid] = journal
 310
 311     def getjournal(self, classname, nodeid):
 312         return self.journals.get(classname, {}).get(nodeid, [])
 313
 314     def pack(self, pack_before):
 315         TODO
 316
 317     #
 318     # Basic transaction support
 319     #
 320     def commit(self, fail_ok=False):
 321         pass
 322
 323     def rollback(self):
 324         TODO
 325
 326     def close(self):
 327         pass
 328
 329 class Class(back_anydbm.Class):
 330     def getnodeids(self, db=None, retired=None):
 331         return self.db.getclassdb(self.classname).keys()
 332
 333 class FileClass(back_anydbm.Class):
 334     def __init__(self, db, classname, **properties):
 335         if not properties.has_key('content'):
 336             properties['content'] = hyperdb.String(indexme='yes')
 337         if not properties.has_key('type'):
 338             properties['type'] = hyperdb.String()
 339         back_anydbm.Class.__init__(self, db, classname, **properties)
 340
 341     def getnodeids(self, db=None, retired=None):
 342         return self.db.getclassdb(self.classname).keys()
 343
 344 # deviation from spec - was called ItemClass
 345 class IssueClass(Class, roundupdb.IssueClass):
 346     # Overridden methods:
 347     def __init__(self, db, classname, **properties):
 348         """The newly-created class automatically includes the "messages",
 349         "files", "nosy", and "superseder" properties.  If the 'properties'
 350         dictionary attempts to specify any of these properties or a
 351         "creation" or "activity" property, a ValueError is raised.
 352         """
 353         if not properties.has_key('title'):
 354             properties['title'] = hyperdb.String(indexme='yes')
 355         if not properties.has_key('messages'):
 356             properties['messages'] = hyperdb.Multilink("msg")
 357         if not properties.has_key('files'):
 358             properties['files'] = hyperdb.Multilink("file")
 359         if not properties.has_key('nosy'):
 360             # note: journalling is turned off as it really just wastes
 361             # space. this behaviour may be overridden in an instance
 362             properties['nosy'] = hyperdb.Multilink("user", do_journal="no")
 363         if not properties.has_key('superseder'):
 364             properties['superseder'] = hyperdb.Multilink(classname)
 365         Class.__init__(self, db, classname, **properties)
 366
 367 # vim: set et sts=4 sw=4 :