Python TestApp.set_cookie方法代码示例

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import set_cookie [as 别名]
def test_invalid_cookie_cookietype():
    # This is not actually a cookie only session, but we still test the cookie part.
    options = {'session.validate_key':'hoobermas', 'session.type':'cookie'}
    app = TestApp(SessionMiddleware(simple_app, **options))

    res = app.get('/')
    assert 'current value is: 1' in res

    # Set an invalid cookie.
    app.set_cookie('cb_/zabbix/actionconf.php_parts', 'HI')
    res = app.get('/')
    assert 'current value is: 2' in res, res

    res = app.get('/')
    assert 'current value is: 3' in res, res

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import set_cookie [as 别名]

#.........这里部分代码省略.........
        request.context = DummyResource()
        request.userdb = self.userdb
        request.userdb_new = self.userdb_new
        request.db = self.db
        request.registry.settings = self.settings

        def propagate_user_changes(user):
            """
            Make sure there is a request.context.propagate_user_changes in testing too.
            """
            logger.debug('FREDRIK: Testing dummy_request.context propagate_user_changes')
            return self.request.amrelay.request_sync(user)

        request.context.propagate_user_changes = propagate_user_changes

        return request

    def set_logged(self, email='[email protected]', extra_session_data={}):
        request = self.set_user_cookie(email)
        user_obj = self.userdb.get_user_by_mail(email, raise_on_missing=True)
        if not user_obj:
            logging.error("User {!s} not found in database {!r}. Users:".format(email, self.userdb))
            for this in self.userdb._get_all_userdocs():
                this_user = OldUser(this)
                logging.debug("  User: {!s}".format(this_user))
        # user only exists in eduid-userdb, so need to clear modified-ts to be able
        # to save it to eduid-dashboard.profiles
        user_obj.set_modified_ts(None)
        dummy = DummyRequest()
        dummy.session = {
            'eduPersonAssurance': loa(3),
            'eduPersonIdentityProofing': loa(3),
        }
        store_session_user(dummy, user_obj)
        # XXX ought to set self.user = user_obj
        self.logged_in_user = self.userdb_new.get_user_by_id(user_obj.get_id())
        dummy.session.update(extra_session_data)
        request = self.add_to_session(dummy.session)
        return request

    def set_user_cookie(self, user_id):
        request = TestRequest.blank('', {})
        request.registry = self.testapp.app.registry
        remember_headers = remember(request, user_id)
        cookie_value = remember_headers[0][1].split('"')[1]
        self.testapp.set_cookie('auth_tkt', cookie_value)
        return request

    def add_to_session(self, data):
        # Log warning since we're moving away from direct request.session access
        logger.warning('Add to session called with data: {!r}'.format(data))
        queryUtility = self.testapp.app.registry.queryUtility
        session_factory = queryUtility(ISessionFactory)
        request = self.dummy_request()
        session = session_factory(request)
        for key, value in data.items():
            session[key] = value
        session.persist()
        self.testapp.set_cookie(self.settings['session.key'], session._session.token)
        return request

    def check_values(self, fields, values, ignore_not_found=[]):
        for field in fields:
            if field.attrs['type'] == 'checkbox':
                # A webtest.app.Checkbox only has a value if it is checked (!)
                old_status = field.checked
                field.checked = True
                if field.value in values:
                    logger.debug("Checked checkbox {!r} (value {!r})".format(field.id, field.value))
                    values.remove(field.value)
                else:
                    # restore the checkbox whose value was not found in values
                    field.checked = False
        values = [x for x in values if x not in ignore_not_found]
        self.assertEqual(values, [], "Failed checking one or more checkboxes: {!r}".format(values))

    def values_are_checked(self, fields, values):
        checked = [f.value for f in fields if f.value is not None]

        self.assertEqual(values, checked)

    def sync_user_from_dashboard_to_userdb(self, user_id, old_format = True):
        """
        When there is no eduid-dashboard-amp Attribute Manager plugin loaded to
        sync users from dashboard to userdb, this crude function can do it.

        :param user_id: User id
        :param old_format: Write in old format to userdb

        :type user_id: ObjectId
        :type old_format: bool
        :return:
        """
        user = self.dashboard_db.get_user_by_id(user_id)
        logger.debug('Syncing user {!s} from dashboard to userdb'.format(user))
        test_doc = {'_id': user_id}
        user_doc = user.to_dict(old_userdb_format=old_format)
        # Fixups to turn the DashboardUser into a User
        del user_doc['terminated']
        self.userdb_new._coll.update(test_doc, user_doc, upsert=False)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import set_cookie [as 别名]
class Saml2RequestTests(MongoTestCase):
    """Base TestCase for those tests usign saml2 that need a full environment
       setup
    """

    def setUp(self, settings={}):
        super(Saml2RequestTests, self).setUp(celery, get_attribute_manager, userdb_use_old_format=True)

        self.settings = {
            'saml2.settings_module': path.join(path.dirname(__file__),
                                               'tests/data/saml2_settings.py'),
            'saml2.login_redirect_url': '/',
            'saml2.logout_redirect_url': '/',
            'saml2.strip_saml_user_suffix': '@test',
            'auth_tk_secret': '123456',
            'testing': True,
            'jinja2.directories': 'eduiddashboard:saml2/templates',
            'jinja2.undefined': 'strict',
            'jinja2.filters': """
                route_url = pyramid_jinja2.filters:route_url_filter
                static_url = pyramid_jinja2.filters:static_url_filter
            """,
            'session.key': 'sessid',
            'session.secret': '123341234',
            'session.cookie_domain': 'localhost',
            'session.cookie_path': '/',
            'session.cookie_max_age': '3600',
            'session.cookie_httponly': True,
            'session.cookie_secure': False,
        }
        self.settings.update(settings)

        if not self.settings.get('groups_callback', None):
            self.settings['groups_callback'] = dummy_groups_callback

        self.settings['mongo_uri'] = self.mongodb_uri('')

        self.redis_instance = RedisTemporaryInstance.get_instance()
        self.settings['REDIS_HOST'] = 'localhost'
        self.settings['REDIS_PORT'] = self.redis_instance._port
        self.settings['REDIS_DB'] = '0'
        self.redis_conn = redis.Redis(host='localhost',
                port=self.redis_instance._port, db=0)

        app = saml2_main({}, **self.settings)
        self.testapp = TestApp(app)

        self.config = testing.setUp()
        self.config.registry.settings = self.settings
        self.config.registry.registerUtility(self, IDebugLogger)
        self.userdb = app.registry.settings['userdb']
        self.db = app.registry.settings['db']

    def tearDown(self):
        super(Saml2RequestTests, self).tearDown()
        for k in self.redis_conn.keys():
            self.redis_conn.delete(k)
        self.testapp.reset()

    def set_user_cookie(self, user_id):
        request = TestRequest.blank('', {})
        request.registry = self.testapp.app.registry
        remember_headers = remember(request, user_id)
        cookie_value = remember_headers[0][1].split('"')[1]
        self.testapp.set_cookie('auth_tkt', cookie_value)
        return request

    def dummy_request(self):
        request = DummyRequest()
        request.context = DummyResource()
        request.userdb = self.userdb
        request.db = self.db
        request.registry.settings = self.settings
        return request

    def get_request_with_session(self):
        queryUtility = self.testapp.app.registry.queryUtility
        session_factory = queryUtility(ISessionFactory)

        request = self.dummy_request()
        session = session_factory(request)
        session.persist()
        self.testapp.set_cookie(self.settings['session.key'], session._session.token)
        self.pol = self.config.testing_securitypolicy(
            'user', ('editors', ),
            permissive=False, remember_result=True)
        return request

    def get_fake_session_info(self, eppn=None):
        session_info = {
            'authn_info': [
                ('urn:oasis:names:tc:SAML:2.0:ac:classes:Password', [])
            ],
            'name_id': None,
            'not_on_or_after': 1371671386,
            'came_from': u'/',
            'ava': {
                'cn': ['John'],
                'objectclass': ['top', 'inetOrgPerson', 'person', 'eduPerson'],
                'userpassword': ['1234'],
#.........这里部分代码省略.........

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import set_cookie [as 别名]
class TestCookie(unittest.TestCase):
    """Tests API functions associated with VM actions.
       Note that all tests are in-process, we don't actually start a http server.
    """
    def setUp(self):
        """Launch pserve using webtest with test settings"""
        self.appconf = get_app(test_ini)
        self.app = TestApp(self.appconf)

        # Punch in new administrator account with direct server call

        server.choose_engine("SQLite")  # Sets global var "engine" - in the
                                        # case of SQLite this is a fresh RAM
                                        # DB each time.

        # Create new user. This will implicitly generate the tables.
        id1 = server.create_user(None, "testuser", "testuser", "testuser")
        server.touch_to_add_user_group("testuser", "users")
        server.touch_to_add_password(id1, "testpass")

        id2 = server.create_user(None, "administrator", "administrator", "administrator")
        server.touch_to_add_user_group("administrator", "administrators")
        server.touch_to_add_password(id2, "adminpass")

    """Confirm lack of any cookie without authentication."""
    def test_no_cookie_without_auth(self):
        """ No cookie should be set when calling an endpoint that
            does not require authorization.
        """
        self.app.authorization = None
        r = self.app.get("/", status=200)

        self.assertEqual(r.headers.get('Set-Cookie', 'empty'), 'empty')

        #Equivalently:
        self.assertEqual(self.app.cookies, {})

    def test_no_username(self):
        """ The DB API should return a 401 unauthorised if I submit a request
            with no username / password provided.
            Similar to test_unauthenticated_api but with an extra check that no
            cookie is set.
        """
        self.app.authorization = None
        r = self.app.get("/users/testuser", status=401)

        self.assertEqual(r.headers.get('Set-Cookie', 'empty'), 'empty')


    def test_invalid_username(self):
        """ The DB API should return a 401 unauthorised if I submit a bad
            username / password combination.  And again no cookie
        """
        self.app.authorization = ('Basic', ('invaliduser', 'invalidpassword'))

        r = self.app.get("/users/testuser", status=401)
        self.assertEqual(r.headers.get('Set-Cookie', 'empty'), 'empty')

    def test_valid_cookie(self):
        """Confirm cookie returned upon authentication.
        The DB API should return a cookie if I submit a correct username
        and password. The cookie should allow me to make a successful request
        using it alone. """

        self.app.authorization = ('Basic', ('testuser', 'testpass'))
        r = self.app.get("/users/testuser", status=200)
        cookie = self.app.cookies['auth_tkt']

        self.app.reset()                         # clear cookie cache
        self.app.authorization = None            # remove auth credentials
        self.app.set_cookie("auth_tkt", cookie)  # set cookie to old value

        r = self.app.get("/users/testuser", status=200)

        #Furthermore, we should still get the same cookie on the second call
        self.assertEqual(self.app.cookies['auth_tkt'], cookie)

    def test_broken_cookie(self):
        """ The DB API should refuse to service a request with a broken cookie. """

        self.app.authorization = ('Basic', ('testuser', 'testpass'))
        r = self.app.get("/users/testuser", status=200)
        cookie = 'I am a fish'

        self.app.reset()                         # clear cookie cache
        self.app.authorization = None            # remove auth credentials
        self.app.set_cookie("auth_tkt", cookie)  # set cookie to bad value
        r = self.app.get("/users/testuser", status=401, expect_errors=False)

    def test_invalid_cookie(self):
        """ The DB API should refuse to service a request with an invalid cookie. """

        self.app.authorization = ('Basic', ('testuser', 'testpass'))
        r = self.app.get("/users/testuser", status=200)
        cookie = '94514a32a7923939584470e8fc01f9b073bc3c8171542c8b7deb0' + \
                 'dd459400945553f9ed9dGVzdHVzZXI%3D!userid_type:b64unicode'

        self.app.reset()                         # clear cookie cache
        self.app.authorization = None            # remove auth credentials
        self.app.set_cookie("auth_tkt", cookie)  # set cookie to bad value
#.........这里部分代码省略.........