def _setup_stubs(self):
# If this code is being run without an appserver (eg. via a django
# commandline flag) then setup a default stub environment.
if not have_appserver:
from google.appengine.tools import dev_appserver_main
args = dev_appserver_main.DEFAULT_ARGS.copy()
args['datastore_path'], args['blobstore_path'], args[
'history_path'] = self._get_paths()
from google.appengine.tools import dev_appserver
dev_appserver.SetupStubs(appid, **args)
# If we're supposed to set up the remote_api, do that now.
if self.remote:
self.setup_remote()
def setup_local_stubs(self, connection):
if self.active_stubs == 'local':
return
from .base import get_datastore_paths
from google.appengine.tools import dev_appserver_main
args = dev_appserver_main.DEFAULT_ARGS.copy()
args.update(get_datastore_paths(connection.settings_dict))
log_level = logging.getLogger().getEffectiveLevel()
logging.getLogger().setLevel(logging.WARNING)
from google.appengine.tools import dev_appserver
dev_appserver.SetupStubs(appid, **args)
logging.getLogger().setLevel(log_level)
self.active_stubs = 'local'
def prep_local_shell():
"""Prepares a local shell by adjusting the datastore paths according to
the settings and setting up the appropriate stubs."""
import settings
args = dev_appserver_main.DEFAULT_ARGS.copy()
# If a custom datastore directory is requested, modify the args for each
# of the datastore paths
if hasattr(settings, 'DATASTORE_DIR'):
ddir = settings.DATASTORE_DIR
for key in ('datastore_path', 'history_path', 'blobstore_path'):
args[key] = os.path.join(ddir, os.path.basename(args[key]))
# Finally, set up the stubs
dev_appserver.SetupStubs(env.gae.app_id, **args)
def start_server(root_path=ROOT_PATH, port=PORT):
dev_appserver.SetupStubs(get_appid(),
login_url=LOGIN_URL,
datastore_path='/dev/null',
history_path='/dev/null',
blobstore_path='/dev/null',
clear_datastore=False)
server = dev_appserver.CreateServer(ROOT_PATH, LOGIN_URL, port,
'/unused/templates/path')
server_thread = threading.Thread(target=server.serve_forever)
server_thread.setDaemon(True)
server_thread.start()
return port
def _setup_environment():
from google.appengine.tools import dev_appserver
config = stub_config.copy()
config['root_path'] = os.getcwd()
config['blobstore_path'] = tempfile.mkdtemp()
config['datastore_path'] = tempfile.mktemp()
config['high_replication'] = True
dev_appserver.SetupStubs('unittest', **config)
import logging
logging.getLogger().setLevel(logging.DEBUG)
def _setup_stubs(self):
# If this code is being run without an appserver (eg. via a django
# commandline flag) then setup a default stub environment.
if not have_appserver:
from google.appengine.tools import dev_appserver_main
args = dev_appserver_main.DEFAULT_ARGS.copy()
args.update(self._get_paths())
log_level = logging.getLogger().getEffectiveLevel()
logging.getLogger().setLevel(logging.WARNING)
from google.appengine.tools import dev_appserver
dev_appserver.SetupStubs(appid, **args)
logging.getLogger().setLevel(log_level)
# If we're supposed to set up the remote_api, do that now.
if self.remote:
self.setup_remote()
def setup_appserver():
"""
Set up appserver stubs as in dev_appserver.
"""
# these require setup_path to have been run
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
# path to app:
root_path = os.path.join(os.path.dirname(__file__), '..')
(config, matcher) = dev_appserver.LoadAppConfig(root_path, {})
# commented out stuff here that checked for SDK updates
dev_appserver.SetupStubs(config.application, **option_dict)
def start_server(root_path=ROOT_PATH, port=PORT, app_id=APP_ID):
dev_appserver.ApplicationLoggingHandler.InitializeTemplates(
'HEADER', 'SCRIPT', 'MIDDLE', 'FOOTER')
dev_appserver.SetupStubs(app_id,
login_url=LOGIN_URL,
datastore_path='/dev/null',
history_path='/dev/null',
clear_datastore=False)
server = dev_appserver.CreateServer(ROOT_PATH, LOGIN_URL, port,
'/unused/templates/path')
server_thread = threading.Thread(target=server.serve_forever)
server_thread.setDaemon(True)
server_thread.start()
return port
def setup():
# Appengine needs this setup.
os.environ["SERVER_SOFTWARE"] = "Dev"
os.environ["AUTH_DOMAIN"] = "gmail.com"
os.environ["USER_EMAIL"] = "*****@*****.**"
datastore_path = rel_path("rietveld_datastore")
history_path = rel_path("rietveld_datastore_history")
options = {"datastore_path": datastore_path,
"history_path": history_path,
"clear_datastore": False,
"login_url": "/_ah/login",
}
dev_appserver.SetupStubs("codereview", **options)
# Rietveld needs its template libraries loaded like this.
library_name = "codereview.library"
if not libraries.get(library_name, None):
add_to_builtins(library_name)
def setup():
from google.appengine.tools import dev_appserver
from google.appengine.tools.dev_appserver_main import (
ARG_CLEAR_DATASTORE,
ARG_LOG_LEVEL,
DEFAULT_ARGS,
logging,
)
option_dict = DEFAULT_ARGS.copy()
option_dict[ARG_CLEAR_DATASTORE] = True
logging.basicConfig(
level=option_dict[ARG_LOG_LEVEL],
format="%(levelname)-8s %(asctime)s %(filename)s] %(message)s")
config, matcher = dev_appserver.LoadAppConfig(root_path, {})
dev_appserver.SetupStubs(config.application, **option_dict)
def setup_local_stubs(self, connection):
if self.active_stubs == 'local':
return
from .base import get_datastore_paths
from google.appengine.tools import dev_appserver_main
args = dev_appserver_main.DEFAULT_ARGS.copy()
args.update(get_datastore_paths(connection.settings_dict))
args.update(connection.settings_dict.get('DEV_APPSERVER_OPTIONS', {}))
log_level = logging.getLogger().getEffectiveLevel()
logging.getLogger().setLevel(logging.WARNING)
try:
from google.appengine.tools import dev_appserver
except ImportError:
from google.appengine.tools import old_dev_appserver as dev_appserver
dev_appserver.SetupStubs('dev~' + appid, **args)
logging.getLogger().setLevel(log_level)
self.active_stubs = 'local'
def setup_for_testing(require_indexes=True, define_queues=[]):
"""Sets up the stubs for testing.
Args:
require_indexes: True if indexes should be required for all indexes.
define_queues: Additional queues that should be available.
"""
from google.appengine.api import apiproxy_stub_map
from google.appengine.api import memcache
from google.appengine.api import queueinfo
from google.appengine.tools import dev_appserver
from google.appengine.tools import dev_appserver_index
before_level = logging.getLogger().getEffectiveLevel()
try:
logging.getLogger().setLevel(100)
root_path = os.path.realpath(os.path.dirname(__file__))
dev_appserver.SetupStubs(
TEST_APP_ID,
root_path=root_path,
login_url='',
datastore_path=tempfile.mktemp(suffix='datastore_stub'),
history_path=tempfile.mktemp(suffix='datastore_history'),
blobstore_path=tempfile.mktemp(suffix='blobstore_stub'),
require_indexes=require_indexes,
clear_datastore=False)
dev_appserver_index.SetupIndexes(TEST_APP_ID, root_path)
# Actually need to flush, even though we've reallocated. Maybe because the
# memcache stub's cache is at the module level, not the API stub?
memcache.flush_all()
finally:
logging.getLogger().setLevel(before_level)
taskqueue_stub = apiproxy_stub_map.apiproxy.GetStub('taskqueue')
taskqueue_stub.queue_yaml_parser = (
lambda x: queueinfo.LoadSingleQueue(
'queue:\n- name: default\n rate: 1/s\n' +
'\n'.join('- name: %s\n rate: 1/s' % name
for name in define_queues)))
def startup_appengine(gae_path='/usr/local/google_appengine',
clear_datastore=False):
# set up app engine paths
sys.path.append(gae_path)
sys.path.append(os.path.join(gae_path, "lib/django"))
sys.path.append(os.path.join(gae_path, "lib/webob"))
sys.path.append(os.path.join(gae_path, "lib/yaml/lib"))
sys.path.append(os.path.join(gae_path, "lib/antlr3"))
# set up dev app server
from google.appengine.tools import dev_appserver
config, explicit_matcher = dev_appserver.LoadAppConfig(chirp_root, {})
from appengine_django.db.base import get_datastore_paths
datastore_path, history_path = get_datastore_paths()
if clear_datastore:
print "clearing datastore"
dev_appserver.SetupStubs(config.application,
clear_datastore=clear_datastore,
datastore_path=datastore_path,
history_path=history_path,
login_url=None)
#!/usr/bin/python
import sys
import os
APP_ENGINE = '/home/jzegan/google_appengine'
sys.path.insert(0, APP_ENGINE)
# so that
import dev_appserver
dev_appserver.fix_sys_path()
APP_PATH = os.path.abspath("/home/jzegan/code/udacityplus/uplusprofiles")
sys.path.insert(0, APP_PATH)
# for the No api proxy found for service "memcache";
# http://blairconrad.wordpress.com/2010/02/20/automated-testing-using-app-engine-service-apis-and-a-memcaching-memoizer/
from google.appengine.tools import dev_appserver as das
from google.appengine.tools.dev_appserver_main import ParseArguments
args, option_dict = ParseArguments(
sys.argv) # Otherwise the option_dict isn't populated.
das.SetupStubs('local', **option_dict)
import unittest
from datastore import user_test
suite1 = user_test.suite()
suite = unittest.TestSuite()
suite.addTest(suite1)
unittest.TextTestRunner(verbosity=2).run(suite)
not dev_process.IsSubprocess()):
server = MakeRpcServer(option_dict)
if skip_sdk_update_check:
logging.info('Skipping update check.')
else:
update_check = appcfg.UpdateCheck(server, appinfo)
update_check.CheckSupportedVersion()
if update_check.AllowedToCheckForUpdates():
update_check.CheckForUpdates()
if dev_process.IsSubprocess():
logging.getLogger().setLevel(logging.WARNING)
try:
dev_appserver.SetupStubs(appinfo.application, **option_dict)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
logging.error(str(exc_type) + ': ' + str(exc_value))
logging.debug(''.join(traceback.format_exception(
exc_type, exc_value, exc_traceback)))
return 1
http_server = dev_appserver.CreateServer(
root_path,
login_url,
port,
sdk_dir=SDK_PATH,
serve_address=address,
allow_skipped_files=allow_skipped_files,
static_caching=static_caching,
#!/usr/bin/env python -i
""" A shell to play around with the local data, assuming:
dev_appserver.py . --use_sqlite --datastore_path=tmp/data """
import os
import logging
from lib.environ import DATASTORE_PATH, setup_environ
setup_environ()
# Setup shell stubs
from google.appengine.tools import dev_appserver_main
from google.appengine.tools import dev_appserver
app_id = os.environ['APPLICATION_ID']
kwargs = dev_appserver_main.DEFAULT_ARGS.copy()
kwargs.update({
'use_sqlite': True,
'datastore_path': DATASTORE_PATH
# todo: blobstore, prospective search
})
dev_appserver.SetupStubs(app_id, **kwargs)
logging.info('DataStore Path: %s' % DATASTORE_PATH)
from google.appengine.ext import testbed
from google.appengine.datastore import datastore_stub_util
##
import sys
from dev_appserver import EXTRA_PATHS
sys.path = EXTRA_PATHS + sys.path
from google.appengine.tools import dev_appserver
from google.appengine.tools.dev_appserver_main import ParseArguments
args, option_dict = ParseArguments(
sys.argv) # Otherwise the option_dict isn't populated.
dev_appserver.SetupStubs('local', **option_dict)
from google.appengine.api import memcache
##
from lib.models.models import User
from lib.models.models import Company
class ModelsTest(unittest.TestCase):
def setUp(self):
# First, create an instance of the Testbed class.
self.testbed = testbed.Testbed()
# Then activate the testbed, which prepares the service stubs for use.
self.testbed.setup_env(app_id='evangeler')
self.testbed.activate()
except dev_appserver.InvalidAppConfigError, e:
logging.error('Application configuration file invalid:\n%s', e)
return 1
if option_dict[ARG_ADMIN_CONSOLE_SERVER] != '':
server = MakeRpcServer(option_dict)
if skip_sdk_update_check:
logging.info('Skipping update check.')
else:
update_check = appcfg.UpdateCheck(server, config)
update_check.CheckSupportedVersion()
if update_check.AllowedToCheckForUpdates():
update_check.CheckForUpdates()
try:
dev_appserver.SetupStubs(config.application, **option_dict)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
logging.error(str(exc_type) + ': ' + str(exc_value))
logging.debug(''.join(
traceback.format_exception(exc_type, exc_value, exc_traceback)))
return 1
http_server = dev_appserver.CreateServer(
root_path,
login_url,
port,
template_dir,
sdk_dir=SDK_PATH,
serve_address=serve_address,
require_indexes=require_indexes,
server = MakeRpcServer(option_dict)
if skip_sdk_update_check:
logging.info('Skipping update check.')
else:
update_check = sdk_update_checker.SDKUpdateChecker(server, appinfo)
update_check.CheckSupportedVersion()
if update_check.AllowedToCheckForUpdates():
update_check.CheckForUpdates()
if dev_process.IsSubprocess():
logging.getLogger().setLevel(logging.WARNING)
try:
dev_appserver.SetupStubs(appinfo.application,
_use_atexit_for_datastore_stub=True,
**option_dict)
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
logging.error(str(exc_type) + ': ' + str(exc_value))
logging.debug(''.join(traceback.format_exception(
exc_type, exc_value, exc_traceback)))
return 1
frontend_port=option_dict.get(ARG_MULTIPROCESS_FRONTEND_PORT, None)
if frontend_port is not None:
frontend_port = int(frontend_port)
http_server = dev_appserver.CreateServer(
root_path,
login_url,
port,
def initialize_service_apis():
from google.appengine.tools import dev_appserver
from google.appengine.tools.dev_appserver_main import ParseArguments
args, option_dict = ParseArguments(sys.argv) # Otherwise the option_dict isn't populated.
dev_appserver.SetupStubs('local', **option_dict)
