The Google App Engine SDK sets up a fairly restrictive Python environment on your local machine to simulate their runtime restrictions. Roughly this consists of no access to sockets and thus barely working httplib, urllib, etc (replaced by urlfetch.fetch()), inability to use Python C modules, and no access to the file system. The SDK lets you run your app very easily using the dev_appserver.py script but I thought, how the heck would I test my app without the dev server?
It turns out this was ridiculously easy. You just run about 10 lines of code at the start of your test suite. Of course, it might change with an SDK upgrade but here's what worked in my tests/__init__.py in today's SDK (besides sys.path munging):
import os
from google.appengine.tools import dev_appserver
from google.appengine.tools.dev_appserver_main import *
option_dict = DEFAULT_ARGS.copy()
option_dict[ARG_CLEAR_DATASTORE] = True
def setup():
## path to app:
root_path = os.path.join(os.path.dirname(__file__), '..')
logging.basicConfig(
level=option_dict[ARG_LOG_LEVEL],
format='%(levelname)-8s %(asctime)s %(filename)s] %(message)s')
config, matcher = dev_appserver.LoadAppConfig(root_path, {})
## commented out stuff that checked for SDK updates
dev_appserver.SetupStubs(config.application, **option_dict)
The setup() is called by nose at the beginning of all tests but if you weren't using nose you could put it at the module level or anywhere else to be called once.
The really cool thing is running tests like this will automatically add indexes for your queries (just like the SDK dev server will) so if you had good code coverage your app would be ready to go live.
Next, you can test your URLs with something like WebTest like so:
from YOURAPP import application
from webtest import TestApp
def test_index():
app = TestApp(application)
response = app.get('/')
...where application is any WSGI app, like one defined in the Hello World tutorial:
from google.appengine.ext import webapp
class MainPage(webapp.RequestHandler):
def get(self):
self.response.out.write('Hello, webapp World!')
application = webapp.WSGIApplication(
[('/', MainPage)], debug=True)
I haven't tried this for Django, but I'm pretty sure it would work as advertised, making your application object this:
application = django.core.handlers.wsgi.WSGIHandler()
And there you have it. The two modules used here aren't in the SDK but that's fine because you don't need to upload them to App Engine anyway. You can run easy_install nose WebTest and be ready to test. You were planning on testing your App Engine site, weren't you? :)
If you want to poke around in the test suite I made for pypi.appspot.com, the code is all in the Pypione project, specifically, the tests directory.
UPDATE
I have since realize the above method does not actually simulate all restrictions, it just inserts some stub modules. Specifically, it doesn't simulate restricting imports of a lot of builtin modules, nor does it remove file() and open().
Jason Pellerin is working on a nose plugin, noseGAE (mentioned below in comments), that aims to get all this simulation accurate. It is coming along nicely.