Ejemplo n.º 1
0
 def testUpdatesApp(self):
     # root = app.RequestProcessor(a='testUpdatesApp.py',model_uri = 'test:')
     app = vesper.app.createApp(baseapp='testUpdatesApp.py', model_uri='test:')        
     app.load()        
     root = app._server
     dataStore = root.defaultStore
     #print 'model', dataStore.model.managedModel.model
     #set timestamp to 0 so tests are reproducible:
     dataStore.model.createTxnTimestamp = lambda *args: 0
     expectedChangeSet = makeChangeset('0A', '0A00001')
     
     #set a notifyChangeset hook to test if its called properly
     self.notifyChangeset = None
     def testNotifyChangeset(changeset):
         self.notifyChangeset = changeset
         def x(d):
             return ['%s=%s' % (k,v) for k,v in sorted(d.items()) 
                                                 if k != 'statements']
         diff = utils.pprintdiff(x(changeset), x(expectedChangeSet))                    
         self.assertEquals(changeset, expectedChangeSet, diff)
     dataStore.model.notifyChangeset = testNotifyChangeset
     
     self.failUnless(root.loadModelHookCalled)
     self.failUnless(not dataStore.model._currentTxn)        
     self.assertEquals(dataStore.model.currentVersion, '0')
     
     #the "foo" request handler defined in testUpdatesApp.py adds content to the store:
     result = root.runActions('http-request', dict(_name='foo'))
     response = "<html><body>page content.</body></html>"
     self.assertEquals(response, result)        
     self.assertEquals(dataStore.model.currentVersion, '0A00001')
     
     self.assertEquals(root.updateResults['_added']['data'], 
         [{'comment': u'page content.', 'id': '@a_resource', 'label': 'foo'}])
     self.assertEquals(root.updateResults['_addedStatements'], 
         [('a_resource', 'comment', 'page content.', 'L', ''), 
         ('a_resource', 'label', 'foo', 'L', '')])
     self.assertEquals(root.updateResults['_removedStatements'], [])
     self.assertEquals(root.updateResults['_removed']['data'], [])        
     self.failUnless(self.notifyChangeset)
     
     #this request doesn't update the store so updateResults should be empty
     root.updateResults = {}
     result = root.runActions('http-request', dict(_name='jj'))                
     self.assertEquals('<html><body>not found!</body></html>', result)
     self.assertEquals(dataStore.model.currentVersion, '0A00001')
     
     self.failUnless('_addedStatements' not in root.updateResults, root.updateResults)
     self.failUnless('_added' not in root.updateResults)
     self.failUnless('_removedStatements' not in root.updateResults)
     self.failUnless('_removed' not in root.updateResults)
     
     try:
         #merging our own changeset in again should throw an error:
         dataStore.merge(self.notifyChangeset)
     except RuntimeError, e:
         self.assertEquals(str(e), 'merge received changeset from itself: 0A')
Ejemplo n.º 2
0
 def testMinimalApp(self):
     app = vesper.app.createApp(baseapp='testMinimalApp.py', model_uri='test:')
     app.load()
     root = app._server
     result = root.runActions('http-request', dict(_name='foo'))
     response = "<html><body>page content.</body></html>"
     self.assertEquals(response, result)
     
     #XXX test for InputSource
     #result = app.InputSource.DefaultFactory.fromUri(
     #    'site:///foo', resolver=root.resolver).read()    
     #print type(result), repr(result), result
     self.assertEquals(response, result)
     
     result = root.runActions('http-request', dict(_name='jj'))
     #print type(result), result
     self.assertEquals( '<html><body>not found!</body></html>', result)
Ejemplo n.º 3
0
 def _testErrorHandling(self, appVars=None):
     app = vesper.app.createApp(baseapp='testErrorHandling-config.py', model_uri='test:', **(appVars or {}))
     app.load()
     root = app._server
     #make sure the error handler is run and sets the status code to 404 instead of the default 200
     kw = dict(_name='foo', 
                 _responseHeaders=dict(_status="200 OK"), _environ={})
     result = root.handleHTTPRequest(kw)
     
     self.assertEquals(kw['_responseHeaders']['_status'], '%d %s' % (404, root.statusMessages[404]))
     response = "404 not found"
     self.assertEquals(response, result)
     
     kw = dict(_name='errorInCommit', 
                 _responseHeaders=dict(_status="200 OK"), _environ={})
     result = root.handleHTTPRequest(kw)
     self.assertEquals(kw['_responseHeaders']['_status'], '%d %s' % (503, root.statusMessages[503]))
     response = 'badCommit: True'
     self.assertEquals(response, result)
Ejemplo n.º 4
0
    def testSequencerApp(self):
        app = vesper.app.createApp(baseapp='testSequencerApp.py', model_uri='test:')
        app.load()
        root = app._server
        result = root.runActions('http-request', dict(_name='foo'))
        self.assertEquals("<html><body>page content.</body></html>", result)

        app = vesper.app.createApp(baseapp='testSequencerApp.py', model_uri='test:')
        app.load()
        root = app._server
        # XXX createApp doesn't specify whether to create a RequestProcessor or HTTPRequestProcessor
        # root = web.HTTPRequestProcessor(a='testSequencerApp.py',model_uri = 'test:')
        kw = dict(_name='no such page', _responseHeaders={}, _environ={})
        result = root.handleHTTPRequest(kw)
        self.assertEquals(kw['_responseHeaders']['_status'],"404 Not Found")

        kw = dict(_name='/static/testfile.txt', 
            _responseHeaders=dict(_status="200 OK"), _environ={})
        result = root.handleHTTPRequest(kw)
        self.assertEquals(result.read().strip(), "test file")
Ejemplo n.º 5
0
    def testCreateApp(self):
        #this is minimal logconfig that python's logger seems to accept:
        app = vesper.app.createApp(static_path=['static'], 
          logconfig = '''
          [loggers]
          keys=root

          [handlers]
          keys=hand01

          [formatters]
          keys=form01

          [logger_root]
          level=DEBUG
          handlers=hand01

          [handler_hand01]
          class=StreamHandler
          level=NOTSET
          formatter=form01
          args=(sys.stdout,)

          [formatter_form01]
          format=%(asctime)s %(levelname)s %(name)s %(message)s
          datefmt=%d %b %H:%M:%S
          '''
        )
        root = app.load()
        self.failUnless(root)
        
        cmdline = ['-x', '--foo=bar', '--transaction_log=test.log', '-fname', '-c', 'test.config']
        app = vesper.app.createApp()
        root = app.run(cmdline=cmdline)
        self.assertEquals(app.foo, 'bar')
        self.assertEquals(app.baz, 1)
        self.assertEquals(app.f, 'name')
        self.assertEquals(root.defaultStore.transaction_log, 'test.log')
        
        #test trying to loading a store with the wrong kind of file
        cmdline = ['-s', 'test.config']
        app = vesper.app.createApp()
        from vesper.data.base.utils import ParseException
        try:
            root = app.run(cmdline=cmdline)
        except ParseException, e: 
            #XXX should report better error message when failing to load store
            self.assertEquals(str(e), 'unrecognized or invalid file contents')
Ejemplo n.º 6
0
    def testMultipleStores(self):
        app = vesper.app.createApp(stores = { 
        'config' : dict(storage_template='''{
            "id" : "@c1", "prop" : 1
        }''', model_options=dict(
                serializeOptions = dict(pjson=dict(nameMap=None))
            )
        ),
          'data' : dict(default_store=True, storage_template='''{
          "id" : "@d1", "prop" : 1
        }''')
        }, storeDefaults=dict(model_options=dict(
            serializeOptions = dict(pjson=dict(nameMap={'refpattern': '!((::)?URIREF)'}))
        ))
        )
        root = app.load()
        self.failUnless(root and root.defaultStore is root.stores.data)
        self.assertEquals(root.stores.config.model_options, 
                    {'serializeOptions': {'pjson': {'nameMap': None}}})
        self.assertEquals(root.stores.data.model_options, {'serializeOptions':
                {'pjson': {'nameMap': {'refpattern': '!((::)?URIREF)'}}}})

        def transaction():
            root.stores.config.update(dict(id='c2', prop2=1))
            root.stores.data.update(dict(id='d1', prop2=1))
        root.executeTransaction(transaction)
        
        cdata = [{'id': '@c2', 'prop2': 1}, {'id': '@c1', u'prop': 1}]
        ddata = [{'id': '!d1', 'prop2': 1, u'prop': 1}]
        self.assertEquals(root.stores.config.query("{*}"), cdata)
        self.assertEquals(root.defaultStore.query("{*}"), ddata)
        
        #test that both stores rollback
        def transaction2():
            root.stores.config.update(dict(id='c2', prop3=1))
            root.stores.data.update(dict(id='d1', prop3=1))
            raise Error()
        try:
            root.executeTransaction(transaction2)
        except:
            pass
        else:
            self.fail('should have raised an error')
        self.assertEquals(root.stores.config.query("{*}"), cdata)
        self.assertEquals(root.defaultStore.query("{*}"), ddata)
Ejemplo n.º 7
0
    def testCreateApp(self):
        #this is minimal logconfig that python's logger seems to accept:
        app = vesper.app.createApp(static_path=['static'], 
          logconfig = '''
          [loggers]
          keys=root

          [handlers]
          keys=hand01

          [formatters]
          keys=form01

          [logger_root]
          level=DEBUG
          handlers=hand01

          [handler_hand01]
          class=StreamHandler
          level=NOTSET
          formatter=form01
          args=(sys.stdout,)

          [formatter_form01]
          format=%(asctime)s %(levelname)s %(name)s %(message)s
          datefmt=%d %b %H:%M:%S
          '''
        )
        root = app.load()
        self.failUnless(root)
        
        cmdline = ['-x', '--foo=bar', '--transaction_log=test.log', '-fname', '-c', 'test.config']
        called = False
        @vesper.app.Command("foo")
        def testCmdFoo(kw, retVal):
            self.assertEquals(kw._params.foo, 'bar')
            self.assertEquals(kw._params.f, 'name')
            kw.__server__.testCmdCalled = True

        @vesper.app.Command("bar")
        def testCmdBar(kw, retVal):
            self.fail("shouldn't have been called")
            return retVal

        app = vesper.app.createApp(actions = {
            'run-cmds' : [testCmdFoo, testCmdBar, lambda x,y: y],
        })
        root = app.run(cmdline=cmdline)
        self.assertEquals(app.foo, 'bar')
        self.assertEquals(app.baz, 1)
        self.assertEquals(app.f, 'name')
        self.assertEquals(root.defaultStore.transaction_log, 'test.log')
        self.failUnless(root.testCmdCalled ) 
        
        #test trying to loading a store with the wrong kind of file
        cmdline = ['-s', 'test.config']
        app = vesper.app.createApp()
        from vesper.data.base.utils import ParseException
        try:
            root = app.run(cmdline=cmdline)
        except ParseException, e: 
            #XXX should report better error message when failing to load store
            self.assertEquals(str(e), 'unrecognized or invalid file contents')