Python Testbed.init_memcache_stub方法代码示例

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
 def test_save(self):
     testbed = Testbed()
     testbed.activate()
     testbed.init_datastore_v3_stub()
     testbed.init_memcache_stub()
     s = mommy.save_one(Stub)
     self.assertIsNotNone(s.key)
     testbed.deactivate()

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
  def setUp(self):
    tb = Testbed()
    tb.activate()
    tb.init_datastore_v3_stub()
    tb.init_memcache_stub()
    tb.init_user_stub()
    self.testbed = tb

    self.orig_http = set_http_mock()
    self.orig_user = set_user_mock()
    
    self.current_user = users.get_current_user()
    self.secret = 'xsrfsecret123'
    self.cache = CredentialsStore()
    self.clear_cache()

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
class _MyTest(unittest.TestCase):
    def setUp(self):
        unittest.TestCase.setUp(self)
        try:
            import webtest
        except ImportError:
            import setuptools.command.easy_install as easy_install

            easy_install.main(["WebTest"])
            exit()
        wsgi_application = webapp.WSGIApplication(paths)
        self.test_app = webtest.TestApp(wsgi_application)
        from google.appengine.ext.testbed import Testbed

        self.testbed = Testbed()
        self.testbed.activate()
        self.testbed.init_datastore_v3_stub()
        self.testbed.init_memcache_stub()

    def tearDown(self):
        self.testbed.deactivate()
        unittest.TestCase.tearDown(self)


    def test_Path(self):
        response = self.test_app.get("/_Path")
        self.assertEqual(response.status, "200 OK")
        self.assertEqual(response.headers["Content-Type"], 'text/html; charset=utf-8')
        self.assertEqual(response.body, '/_Path')

    def test_Params(self):
        response = self.test_app.request(b"/_Params;ppp?a=b&c=d#e", method=b"GET")
        self.assertEqual(response.headers["a"], "abc")
        self.assertEqual(response.status, "200 OK")
        self.assertEqual(response.headers["Content-Type"], 'text/html; charset=utf-8')
        self.assertEqual(response.body, "")

    def test_Fragment(self):
        response = self.test_app.request(b"/_Fragment?a=b&c=d#e", method=b"GET")
        self.assertEqual(response.status, "200 OK")
        self.assertEqual(response.headers["Content-Type"], 'text/html; charset=utf-8')
        self.assertEqual(response.body, "e")

    def test_Query(self):
        response = self.test_app.request(b"/_Query?a=b&c=d#e", method=b"GET")
        self.assertEqual(response.status, "200 OK")
        self.assertEqual(response.headers["Content-Type"], 'text/html; charset=utf-8')
        self.assertEqual(response.body, "a=b&c=d")

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
def testbed():
    testbed = Testbed()
    testbed.activate()
    # testbed.setup_env(app_id='_')
    os.environ['APPLICATION_ID'] = '_'
    # This is a hack to get things working; `testbed.setup_env` does
    # not seem to be doing the job.
    # See: http://einaregilsson.com/unit-testing-model-classes-in-google-app-engine/

    # Will almost always need datastore for tests that use this fixture.
    testbed.init_datastore_v3_stub()
    # ndb uses memcache, so stub it as well.
    testbed.init_memcache_stub()
    # Clear in-context cache before test.
    ndb.get_context().clear_cache()

    yield testbed

    ndb.get_context().clear_cache()
    testbed.deactivate()

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
class _MyTest(unittest.TestCase):
    def setUp(self):
        unittest.TestCase.setUp(self)
        try:
            import webtest
        except ImportError:
            import setuptools.command.easy_install as easy_install

            easy_install.main(["WebTest"])
            exit()

        wsgi_application = webapp.WSGIApplication(post.paths)
        self.test_app = webtest.TestApp(wsgi_application)
        from google.appengine.ext.testbed import Testbed

        self.testbed = Testbed()
        self.testbed.activate()
        self.testbed.init_datastore_v3_stub()
        self.testbed.init_memcache_stub()

    def tearDown(self):
        self.testbed.deactivate()
        unittest.TestCase.tearDown(self)

    def testGet(self):
        response = self.test_app.get("/post")
        import webtest

        self.assertIsInstance(response, webtest.TestResponse)
        self.assertEqual(response.status, "200 OK")
        self.assertEqual(response.headers["Content-Type"], 'text/plain')

    def testGet2(self):
        TEST_QUERY = "a=b&c=d&e=f"
        response = self.test_app.get("/post?" + TEST_QUERY)
        import webtest

        self.assertIsInstance(response, webtest.TestResponse)
        self.assertEqual(response.status, "200 OK")
        self.assertEqual(response.headers["Content-Type"], 'text/plain')
        print(response.body)

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
class SimpleTest(unittest.TestCase):
    """
    """

    def setUp(self):
        """
        """
        self.testbed = Testbed()
        self.testbed.setup_env(app_id='dev~foobar')
        self.testbed.activate()
        self.testbed.init_memcache_stub()
        self.testbed.init_datastore_v3_stub(datastore_file='/tmp/appengine.foobar.kgreen/datastore.db',
                                            use_sqlite=True)

    def tearDown(self):
        self.testbed.deactivate()

    def test_index(self):
        model = DataModel(name='users',
                          value=[PropertyModel(name='first', value='John'),
                                 PropertyModel(name='last', value='Dough')])
        model.put()

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
class BaseAppengineDatastoreTester(unittest.TestCase):

    def setUp(self):
        unittest.TestCase.setUp(self)

        self._testbed = Testbed()
        self._testbed.activate()
        self._testbed.init_datastore_v3_stub()
        self._testbed.init_memcache_stub()
        
    def __init__(self, methodName = None):
        """ 
        Constructor override to allow creation of an instance
        to be used outside the test run process
        Useful for defining helper methods reusable in 
        other test classes
        """
        
        if methodName != None:
            unittest.TestCase.__init__(self, methodName)
        else:
            # Map types to custom assertEqual functions that will compare
            # instances of said type in more detail to generate a more useful
            # error message.
            # Copied from unittest.TestCase
            self._type_equality_funcs = {}
            self.addTypeEqualityFunc(dict, self.assertDictEqual)
            self.addTypeEqualityFunc(list, self.assertListEqual)
            self.addTypeEqualityFunc(tuple, self.assertTupleEqual)
            self.addTypeEqualityFunc(set, self.assertSetEqual)
            self.addTypeEqualityFunc(frozenset, self.assertSetEqual)
            self.addTypeEqualityFunc(unicode, self.assertMultiLineEqual)
            
    def verify_entity_instance(self, instance = None, type = None):
        """ verify that instance is not null, of the specified type, and having a not null key """
        self.assertIsNotNone(instance)
        self.assertIsInstance(instance, type)
        self.assertIsInstance(instance.key(), db.Key)
            

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
class _TestRawDataNdb(TestCase):
    
    TEST_RAWDATA_ID = 12345
    TEST_BODY = "bodybody"
    TEST_QUERY = "a=b&c=d"
    TEST_FRAGMENT = "fragmentfragment"
    TEST_PATH = "/a/b/c"
    TEST_PARAMETERS = ""

    def setUp(self):
        TestCase.setUp(self)
        from google.appengine.ext.testbed import Testbed
        self.testbed = Testbed()
        self.testbed.activate()
        self.testbed.init_datastore_v3_stub()
        self.testbed.init_memcache_stub()
    
    def tearDown(self):
        self.testbed.deactivate()
        TestCase.tearDown(self)
        
    def testGetLast(self):
        key = RawData.fetchByRawDataId(self.TEST_RAWDATA_ID)
        if key is not None: key.delete()
        key = RawData.fetchByRawDataId(self.TEST_RAWDATA_ID)
        self.assertTrue(key is None)
        
        raw_data = RawData()
        raw_data.rawDataId = self.TEST_RAWDATA_ID 
        raw_data.path = self.TEST_PATH
        raw_data.parameters = self.TEST_PARAMETERS
        raw_data.query = self.TEST_QUERY
        raw_data.fragment = self.TEST_FRAGMENT
        raw_data.body = self.TEST_BODY
        raw_data.put()
        
        key = RawData.fetchByRawDataId(self.TEST_RAWDATA_ID)
        self.assertTrue(key is not None)

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
class StubManager(object):

    def __init__(self):
        self.active_stubs = None
        self.pre_test_stubs = None

    def setup_stubs(self, connection):
        if self.active_stubs is not None:
            return
        if not have_appserver:
            self.setup_local_stubs(connection)

    def activate_test_stubs(self, connection):
        from google.appengine.ext.testbed import Testbed
        self.testbed = Testbed()

        if self.active_stubs == 'test':
            return

        os.environ['HTTP_HOST'] = "%s.appspot.com" % appid

        appserver_opts = connection.settings_dict.get('DEV_APPSERVER_OPTIONS', {})
        high_replication = appserver_opts.get('high_replication', False)

        datastore_opts = {}
        if high_replication:
            from google.appengine.datastore import datastore_stub_util
            datastore_opts['consistency_policy'] = datastore_stub_util.PseudoRandomHRConsistencyPolicy(probability=1)

        self.testbed.activate()
        self.pre_test_stubs = self.active_stubs
        self.active_stubs = 'test'
        self.testbed.init_datastore_v3_stub(**datastore_opts)
        self.testbed.init_memcache_stub()
        self.testbed.init_taskqueue_stub(auto_task_running=True, root_path=PROJECT_DIR)
        self.testbed.init_urlfetch_stub()
        self.testbed.init_user_stub()
        self.testbed.init_xmpp_stub()
        self.testbed.init_channel_stub()

    def deactivate_test_stubs(self):
        if self.active_stubs == 'test':
            self.testbed.deactivate()
            self.active_stubs = self.pre_test_stubs

    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)
        from google.appengine.tools import dev_appserver
        dev_appserver.SetupStubs('dev~' + appid, **args)
        logging.getLogger().setLevel(log_level)
        self.active_stubs = 'local'

    def setup_remote_stubs(self, connection):
        if self.active_stubs == 'remote':
            return
        if not connection.remote_api_path:
            from ..utils import appconfig
            for handler in appconfig.handlers:
                if handler.script in REMOTE_API_SCRIPTS:
                    connection.remote_api_path = handler.url.split('(', 1)[0]
                    break
        server = '%s.%s' % (connection.remote_app_id, connection.domain)
        remote_url = 'https://%s%s' % (server, connection.remote_api_path)
        logging.info("Setting up remote_api for '%s' at %s." %
                     (connection.remote_app_id, remote_url))
        if not have_appserver:
            logging.info(
                "Connecting to remote_api handler.\n\n"
                "IMPORTANT: Check your login method settings in the "
                "App Engine Dashboard if you have problems logging in. "
                "Login is only supported for Google Accounts.")
        from google.appengine.ext.remote_api import remote_api_stub
        remote_api_stub.ConfigureRemoteApi(None,
            connection.remote_api_path, auth_func, servername=server,
            secure=connection.secure_remote_api,
            rpc_server_factory=rpc_server_factory)
        retry_delay = 1
        while retry_delay <= 16:
            try:
                remote_api_stub.MaybeInvokeAuthentication()
            except HTTPError, e:
                if not have_appserver:
                    logging.info("Retrying in %d seconds..." % retry_delay)
                time.sleep(retry_delay)
                retry_delay *= 2
            else:
                break
        else:

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
class TestCase(unittest.TestCase):
    """Utility methods for testing.

    This class should be used as the superclass of all other test classes. It
    sets up the necessary test stubs and provides various utility methods to use
    in tests.
    """

    def setUp(self):
        """Initialize stubs for testing.

        This initializes the following fields:
          self.testbed: An App Engine Testbed used for mocking App Engine
            services. This is activated, and any necessary stubs are
            initialized.
          self.testapp: A webtest.TestApp wrapping the CherryPy application.

        Subclasses that define their own setUp method should be sure to call
        this one as well.
        """

        self.__users = {}
        self.__admins = {}

        self.testbed = Testbed()
        self.testbed.activate()
        self.testbed.init_app_identity_stub()
        self.testbed.init_blobstore_stub()
        self.testbed.init_datastore_v3_stub()
        self.testbed.init_files_stub()
        self.testbed.init_memcache_stub()
        self.testbed.init_taskqueue_stub()
        self.testbed.init_user_stub()

        self.testapp = webtest.TestApp(Application())

        # Pretend we are running on AppEngine so that things like the error
        # page that behave differently when run locally act like they do in
        # production.
        os.environ['SERVER_SOFTWARE'] = 'Google App Engine/TESTING'

        # This private key is not actually used for anything other than testing.
        PrivateKey.set('''-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,CEB8C6541017AC8B

q1SgqAfgHXK5cQvtdIF8rkSlbAS6a92T5tYMVKJIW24giF5cw+1++X7X6S5ECykC
/iECExP7WfVlPDVoJMZpWGsYLMPhxncnKfUDICbVgwsO4KKeEv8lYTrvkY1sCZIx
kSja/lGAWpyxBnmxwoLh0LbLJBGUxUgn2Uqv/8Iid+w0m3NlgrllV+kOo4gUYF9q
bestH4nEQj6F0CeI8VPW0FxzMwn0vreHFBT5hul6xbNdB1vnRcz6ed4FiGXoAB5K
/8/Q2qyy1UPe2Hr9IoC6wo4h2kXq7pmhy/rtzU9/gjsGPD33ByavbgHAen0ajY5p
RmCx0AGidK9T6/SNoyDD9CMq7ypL+0JWoCeVoAEw2aZqN4rMJNbKMgPH+ajgiAXe
AWuMVjWN6uTL5+QJmWQct6a6TF8GPKdTcOZfNIXU5U9drHB2hggLcy6XkCYGjVJv
MvLascE4oAtOHnwz7WhrpcmX6F6Fww+TPnFzjk+IGJrnBUnAArEcM13IjiDUgg9B
iLuKimwrqasdBBY3Ua3SRMoG8PJoNKdsk1hDGlpxLnqOVUCvPKZuz4QnFusnUJrR
kiv+aqVBpZYymMh2Q1MWcogA7rL7LIowAkyLzS8dNwDhyk9jbO+1uoFSHKr5BTNv
cMJfCVm8pqhXwCVx3uYnhUzvth7mcEseXh5Dcg1RHka5rCXUz4eVxTkj1u3FOy9o
9jgARPpnDYsXH1lESxmiNZucHa50qI/ezNvQx8CbNa1/+JWoZ77yqM9qnDlXUwDY
1Sxqx9+4kthG9oyCzzUwFvhf1kTEHd0RfIapgjJ16HBQmzLnEPtjPA==
-----END RSA PRIVATE KEY-----''')

        self.dont_be_oauth_user()

    def tearDown(self):
        """Deactivates the stubs initialized in setUp.

        Subclasses that define their own tearDown method should be sure to call
        this one as well.
        """
        self.testbed.deactivate()

    def normal_user(self, name = None):
        """Constructs a non-admin user object.

        Arguments:
          name: A string to distinguish this user from others. Users with
            different names will be distinct, and the same name will always
            refer to the same user. Admin users have a separate namespace from
            non-admin users.

        Returns: The user object.
        """

        if self.__users.has_key(name):
            return self.__users[name]

        email = '[email protected]'
        if name:
            email = 'test-user-%[email protected]' % name

        self.__users[name] = users.User(email = email)
        return self.__users[name]

    def admin_user(self, name = None):
        """Constructs an admin user object.

        Arguments:
          name: A string to distinguish this user from others. Users with
            different names will be distinct, and the same name will always
            refer to the same user. Admin users have a separate namespace from
#.........这里部分代码省略.........

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
import unittest
import webapp2

from google.appengine.api import memcache
from google.appengine.ext import ndb
from google.appengine.ext.testbed import Testbed

testbed = Testbed()
testbed.activate()
testbed.init_datastore_v3_stub()
testbed.init_memcache_stub()
ndb.get_context().clear_cache()

import main

class AppTest(unittest.TestCase):
	def setUp(self):
		ndb.get_context().clear_cache()

	def test_ok(self):
		request = webapp2.Request.blank('/ok')
		response = request.get_response(main.app)
		self.assertEqual(response.status_int, 200)
		self.assertEqual(response.body, 'ok')

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
class StubManager(object):
    def __init__(self):
        self.testbed = Testbed()
        self.active_stubs = None
        self.pre_test_stubs = None

    def setup_stubs(self, connection):
        if self.active_stubs is not None:
            return
        if not have_appserver:
            self.setup_local_stubs(connection)

    def activate_test_stubs(self):
        if self.active_stubs == 'test':
            return
        self.testbed.activate()
        self.pre_test_stubs = self.active_stubs
        self.active_stubs = 'test'
        self.testbed.init_datastore_v3_stub()
        self.testbed.init_memcache_stub()
        self.testbed.init_taskqueue_stub()
        self.testbed.init_urlfetch_stub()
        self.testbed.init_user_stub()
        self.testbed.init_xmpp_stub()
        self.testbed.init_channel_stub()

    def deactivate_test_stubs(self):
        if self.active_stubs == 'test':
            self.testbed.deactivate()
            self.active_stubs = self.pre_test_stubs

    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)
        from google.appengine.tools import dev_appserver
        dev_appserver.SetupStubs(appid, **args)
        logging.getLogger().setLevel(log_level)
        self.active_stubs = 'local'

    def setup_remote_stubs(self, connection):
        if self.active_stubs == 'remote':
            return
        if not connection.remote_api_path:
            from ..utils import appconfig
            for handler in appconfig.handlers:
                if handler.script == REMOTE_API_SCRIPT:
                    connection.remote_api_path = handler.url.split('(', 1)[0]
                    break
        server = '%s.%s' % (connection.remote_app_id, connection.domain)
        remote_url = 'https://%s%s' % (server, connection.remote_api_path)
        logging.info('Setting up remote_api for "%s" at %s' %
                     (connection.remote_app_id, remote_url))
        if not have_appserver:
            print('Connecting to remote_api handler.\n\n'
                  'IMPORTANT: Check your login method settings in the '
                  'App Engine Dashboard if you have problems logging in. '
                  'Login is only supported for Google Accounts.\n')
        from google.appengine.ext.remote_api import remote_api_stub
        remote_api_stub.ConfigureRemoteApi(None,
            connection.remote_api_path, auth_func, servername=server,
            secure=connection.secure_remote_api,
            rpc_server_factory=rpc_server_factory)
        retry_delay = 1
        while retry_delay <= 16:
            try:
                remote_api_stub.MaybeInvokeAuthentication()
            except HTTPError, e:
                if not have_appserver:
                    print 'Retrying in %d seconds...' % retry_delay
                time.sleep(retry_delay)
                retry_delay *= 2
            else:
                break
        else:

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
class StubManager(object):
    def __init__(self):
        self.testbed = None
        self.active_stubs = None
        self.pre_test_stubs = None

    def setup_stubs(self, connection):
        if self.active_stubs is not None:
            return
        if not have_appserver:
            self.activate_stubs(connection)

    def activate_stubs(self, connection):
        try:
            from google.appengine.tools import dev_appserver_main

            self.setup_local_stubs(connection)
        except ImportError:
            self.activate_test_stubs(connection)

    def reset_stubs(self, connection, datastore_path=None):
        if self.active_stubs == "test":
            self.deactivate_test_stubs()
            self.activate_test_stubs(connection, datastore_path)

        elif self.active_stubs == "local":
            self.setup_local_stubs(connection)

        elif self.active_stubs == "remote":
            self.setup_remote_stubs(connection)

    def activate_test_stubs(self, connection, datastore_path=None):
        if self.active_stubs == "test":
            return

        if self.testbed is None:
            from google.appengine.ext.testbed import Testbed

            self.testbed = Testbed()

        self.testbed.activate()
        self.pre_test_stubs = self.active_stubs
        self.active_stubs = "test"

        os.environ["APPLICATION_ID"] = "dev~" + appid
        os.environ["HTTP_HOST"] = "%s.appspot.com" % appid

        appserver_opts = connection.settings_dict.get("DEV_APPSERVER_OPTIONS", {})
        high_replication = appserver_opts.get("high_replication", False)
        require_indexes = appserver_opts.get("require_indexes", False)
        use_sqlite = appserver_opts.get("use_sqlite", False)

        datastore_opts = {"require_indexes": require_indexes, "use_sqlite": use_sqlite}

        if high_replication:
            from google.appengine.datastore import datastore_stub_util

            datastore_opts["consistency_policy"] = datastore_stub_util.PseudoRandomHRConsistencyPolicy(probability=1)

        self.testbed.init_datastore_v3_stub(datastore_file=datastore_path, **datastore_opts)
        self.testbed.init_memcache_stub()
        self.testbed.init_taskqueue_stub(auto_task_running=True, root_path=PROJECT_DIR)
        self.testbed.init_urlfetch_stub()
        self.testbed.init_user_stub()
        self.testbed.init_xmpp_stub()
        self.testbed.init_channel_stub()
        self.testbed.init_app_identity_stub()
        self.testbed.init_blobstore_stub()
        self.testbed.init_files_stub()
        self.testbed.init_images_stub()

    def deactivate_test_stubs(self):
        if self.active_stubs == "test":
            self.testbed.deactivate()
            self.active_stubs = self.pre_test_stubs

    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_remote_stubs(self, connection):
        if self.active_stubs == "remote":
            return
#.........这里部分代码省略.........

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import init_memcache_stub [as 别名]
def init_gae_api_stubs():
    testbed = Testbed()
    testbed.activate()
    testbed.init_datastore_v3_stub()
    testbed.init_memcache_stub()
    return testbed