Python Testbed.activate方法代码示例

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import activate [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 activate [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 activate [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 activate [as 别名]
class TestBase(TestCase):
    def setUp(self):
        from google.appengine.ext.testbed import Testbed

        self.testbed = Testbed()
        self.testbed.activate()
        # default setup with no param
        # you may re-setup in a test code by using this.
        self.setUpPyramid()

    def setUpPyramid(self, **kwargs):
        import netprintbox
        self.config = testing.setUp(**kwargs)
        self.config.include('netprintbox')

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

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import activate [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 activate [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 activate [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 activate [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 activate [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 activate [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 activate [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 activate [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 activate [as 别名]
class FunctionalClientTest(TestCase):
    def setUp(self):
        from google.appengine.ext.testbed import Testbed

        self.testbed = Testbed()
        self.testbed.activate()
        self.testbed.init_urlfetch_stub()

        self.username = os.environ.get('NETPRINT_USERNAME')
        self.password = os.environ.get('NETPRINT_PASSWORD')
        if self.username is None or self.password is None:
            raise SkipTest("Need both "
                           "NETPRINT_USERNAME and NETPRINT_PASSWORD")

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

    def _getOUT(self):
        import httplib2
        from netprint import Client

        httplib2.debuglevel = 1
        return Client(httplib2.Http(),
                      'Mozilla/5.0 '
                      '(Macintosh; U;Intel Mac OS X 10_6_3; ja-jp) '
                      'AppleWebKit/533.16 (KHTML, like Gecko) '
                      'Version/5.0 Safari/533.16')

    @attr('functional', 'heavy')
    def test_login(self):
        client = self._getOUT()
        client.login(self.username, self.password, retry=1)
        self.assertIsNotNone(client.session_key)

    @attr('functional', 'heavy')
    def test_session_error(self):
        from netprint import UnexpectedContent

        client1 = self._getOUT()
        client2 = self._getOUT()
        client1.login(self.username, self.password, 1)
        client2.login(self.username, self.password, 1)
        self.assertNotEqual(client1.session_key, client2.session_key)
        self.assertRaises(UnexpectedContent, client1.reload)

    @attr('functional', 'heavy')
    def test_send_delete(self):
        client = self._getOUT()
        client.login(self.username, self.password, retry=1)

        client.send('tests/data/数独01.jpg')
        client.reload()
        self.assertIn(u'数独01', [item.name for item in client.list()])

        client.delete(item)
        client.reload()
        self.assertNotIn(u'数独01', [item.name for item in client.list()])

    @attr('functional', 'heavy')
    def test_send_delete_with_fileobj(self):
        client = self._getOUT()
        client.login(self.username, self.password, retry=1)

        client.send(file('tests/data/数独01.jpg'))
        client.reload()
        self.assertIn(u'数独01', [item.name for item in client.list()])

        client.delete(item)
        client.reload()
        self.assertNotIn(u'数独01', [item.name for item in client.list()])

# 需要导入模块: from google.appengine.ext.testbed import Testbed [as 别名]
# 或者: from google.appengine.ext.testbed.Testbed import activate [as 别名]
#!/usr/bin/env python
# coding: utf-8

import os
import logging

from dev_appserver import fix_sys_path
fix_sys_path()
from google.appengine.ext.testbed import Testbed
tb = Testbed()
tb.activate()
os.environ['APPLICATION_ID'] = 'rss-xmpp'
tb.init_xmpp_stub()
tb.init_datastore_v3_stub()
tb.init_urlfetch_stub()

from rss_xmpp.main import *
from google.appengine.api import xmpp
from rss_xmpp import feedcrawler

import unittest

url = 'http://feeds.feedburner.com/github'

class XMPPTestMessage(xmpp.Message):
    def reply(self, body, message_type="chat", raw_xml=False, send_message=xmpp.send_message):
        super(XMPPTestMessage, self).reply(body, message_type, raw_xml, send_message)
        logging.debug('\nSent message:\n' + '='*80 + '\n' + body + '='*80 + '\n')

class TestRSSXMPP(unittest.TestCase):

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