示例#1
0
 def test_count_all(self):
     ids = [self.user.id]
     for _ in range(3):
         user = yield User(first_name="blah").save()
         ids.append(user.id)
     results = yield User.count()
     self.assertEqual(4, results)
示例#2
0
def login():
    if request.method == 'GET':
        return '''
               <form action='login' method='POST'>
                <input type='text' name='username' id='username' placeholder='username'></input>
                <input type='password' name='password' id='password' placeholder='password'></input>
                <input type='submit' name='submit'></input>
               </form>
               '''

    username = request.form['username']
    try:
        if request.form['password'] == users[username]['password']:
            user = User()

            #Attribute this user to a player object
            player_to_be_attributed = None
            for player in glob.players:
                if not player.isAttributed():
                    player_to_be_attributed = player
                    break
            player_to_be_attributed.attribute()

            user.id = username
            glob.usernameToPlayer[username] = player_to_be_attributed
            flask_login.login_user(user)
            return flask.redirect(flask.url_for('index'))

    except KeyError:
        return flask.redirect(flask.url_for('unprotected'))
示例#3
0
    def test_findOrCreate(self):
        # make sure we didn't create a new user
        r = yield User.findOrCreate(first_name="First")
        self.assertEqual(r.id, self.user.id)

        # make sure we do create a new user
        r = yield User.findOrCreate(first_name="First", last_name="Non")
        self.assertTrue(r.id != self.user.id)
示例#4
0
 def test_count(self):
     ids = []
     for _ in range(3):
         user = yield User(first_name="blah").save()
         ids.append(user.id)
     yield User(first_name="not blah").save()
     results = yield User.count(where=["first_name = ?", "blah"])
     self.assertEqual(3, results)
示例#5
0
 def test_all(self):
     ids = [self.user.id]
     for _ in range(3):
         user = yield User(first_name="blah").save()
         ids.append(user.id)
     results = yield User.all()
     resultids = [result.id for result in results]
     self.assertEqual(ids, resultids)
示例#6
0
    def test_update(self):
        tablename = User.tablename()
        user = yield User(first_name="Another First").save()

        args = {'first_name': "test", "last_name": "foo", "age": 91}
        yield self.dbconfig.update(tablename, args, ['id = ?', user.id])
        yield user.refresh()
        for key, value in args.items():
            self.assertEqual(value, getattr(user, key))
示例#7
0
    def setUp(self):
        self.USER_GNUPGHOME = tempfile.TemporaryDirectory()
        self.ADMIN_GNUPGHOME = tempfile.TemporaryDirectory()
        self.NEW_USER_GNUPGHOME = tempfile.TemporaryDirectory()
        self.NEW_ADMIN_GNUPGHOME = tempfile.TemporaryDirectory()
        self.SEED_DIR = tempfile.TemporaryDirectory()
        self.config = ConfigParser()
        self.config.read_string("""
            [mtls]
            min_lifetime=60
            max_lifetime=0
            seed_dir={seed_dir}

            [ca]
            key = secrets/certs/authority/RootCA.key
            cert = secrets/certs/authority/RootCA.pem
            issuer = My Company Name
            alternate_name = *.myname.com

            [gnupg]
            user={user_gnupghome}
            admin={admin_gnupghome}

            [storage]
            engine=sqlite3

            [storage.sqlite3]
            db_path=:memory:
            """.format(
            user_gnupghome=self.USER_GNUPGHOME.name,
            admin_gnupghome=self.ADMIN_GNUPGHOME.name,
            seed_dir=self.SEED_DIR.name,
        ))
        self.common_name = "user@host"
        self.key = generate_key()
        self.engine = storage.SQLiteStorageEngine(self.config)
        cur = self.engine.conn.cursor()
        cur.execute("DROP TABLE IF EXISTS certs")
        self.engine.conn.commit()
        self.engine.init_db()
        self.cert_processor = CertProcessor(self.config)
        self.user_gpg = gnupg.GPG(gnupghome=self.USER_GNUPGHOME.name)
        self.admin_gpg = gnupg.GPG(gnupghome=self.ADMIN_GNUPGHOME.name)
        self.new_user_gpg = gnupg.GPG(gnupghome=self.NEW_USER_GNUPGHOME.name)
        self.new_admin_gpg = gnupg.GPG(gnupghome=self.NEW_ADMIN_GNUPGHOME.name)
        self.new_users = [
            User("user@host",
                 gen_passwd(),
                 generate_key(),
                 gpg=self.new_user_gpg)
        ]
        self.new_admins = [
            User("admin@host",
                 gen_passwd(),
                 generate_key(),
                 gpg=self.new_admin_gpg)
        ]
示例#8
0
 def test_delete_all(self):
     users = yield User.all()
     ids = [user.id for user in users]
     for _ in range(3):
         yield User(first_name="blah").save()
     yield User.deleteAll(["first_name = ?", "blah"])
     users = yield User.all()
     resultids = [user.id for user in users]
     self.assertEqual(resultids, ids)
示例#9
0
    def test_delete(self):
        tablename = User.tablename()

        yield User(first_name="Another First").save()
        yield self.dbconfig.delete(tablename, ['first_name like ?', "%nother Fir%"])

        result = yield self.dbconfig.select(tablename)
        self.assertEqual(len(result), 1)
        self.assertTrue(result[0]['id'] == self.user.id)
示例#10
0
 def test_find(self):
     ids = []
     for _ in range(3):
         user = yield User(first_name="blah").save()
         ids.append(user.id)
     yield User(first_name="not blah").save()
     results = yield User.find(where=["first_name = ?", "blah"])
     resultids = [result.id for result in results]
     self.assertEqual(ids, resultids)
示例#11
0
 def run(txn):
     tablename = User.tablename()
     args = {'first_name': "test", "last_name": "foo", "age": 91}
     objid = self.dbconfig.insert(tablename, args, txn)
     users = self.dbconfig._doselect(txn, "select * from %s" % User.tablename(), [], User.tablename())
     self.assertEqual(len(users), 2)
     self.assertEqual(users[1]['id'], objid)
     for key, value in args.items():
         self.assertEqual(value, users[1][key])
示例#12
0
    def test_new_rating(self):
        new_rating = self.gl2.create_rating()

        user = User(self.app,
                    username="******",
                    perfs={variant: DEFAULT_PERF
                           for variant in VARIANTS})
        result = user.get_rating("chess", False)
        self.assertEqual(result.mu, new_rating.mu)
示例#13
0
def user_loader(username):
    try:
        if username not in users:
            return
        user = User()
        user.id = username
        user.loadUser(glob.usernameToPlayer[username])
        return user
    except:
        return
示例#14
0
    def setUp(self):
        self.USER_GNUPGHOME = tempfile.TemporaryDirectory()
        self.ADMIN_GNUPGHOME = tempfile.TemporaryDirectory()
        config = ConfigParser()
        config.read_string(
            """
            [ca]
            key = secrets/certs/authority/RootCA.key
            cert = secrets/certs/authority/RootCA.pem
            issuer = My Company Name
            alternate_name = *.myname.com

            [gnupg]
            user={user_gnupghome}
            admin={admin_gnupghome}

            [storage]
            engine=postgres

            [storage.postgres]
            database = mtls
            user = postgres
            password = postgres
            host = localhost
            """.format(
                user_gnupghome=self.USER_GNUPGHOME.name,
                admin_gnupghome=self.ADMIN_GNUPGHOME.name,
            )
        )
        self.common_name = "user@host"
        self.key = generate_key()
        self.engine = storage.PostgresqlStorageEngine(config)
        cur = self.engine.conn.cursor()
        cur.execute("DROP TABLE IF EXISTS certs")
        self.engine.conn.commit()
        self.engine.init_db()

        self.cert_processor = CertProcessor(config)
        self.user_gpg = gnupg.GPG(gnupghome=self.USER_GNUPGHOME.name)
        self.admin_gpg = gnupg.GPG(gnupghome=self.ADMIN_GNUPGHOME.name)
        self.users = [
            User("user@host", gen_passwd(), generate_key(), gpg=self.user_gpg),
            User("user2@host", gen_passwd(), generate_key(), gpg=self.user_gpg),
            User("user3@host", gen_passwd(), generate_key(), gpg=self.user_gpg),
        ]
        self.invalid_users = [
            User("user4@host", gen_passwd(), generate_key(), gpg=self.user_gpg)
        ]
        self.admin_users = [
            User("admin@host", gen_passwd(), generate_key(), gpg=self.admin_gpg)
        ]
        for user in self.users:
            self.user_gpg.import_keys(self.user_gpg.export_keys(user.fingerprint))
        for user in self.admin_users:
            self.admin_gpg.import_keys(self.admin_gpg.export_keys(user.fingerprint))
示例#15
0
    def test_joinMultipleWheres(self):
        yield User(first_name="First", last_name="Last", age=20).save()

        first = ['first_name = ?', "First"]
        last = ['last_name = ?', "Last"]
        age = ['age <> ?', 20]

        where = utils.joinMultipleWheres([first, last, age], joiner='AND')

        results = yield User.count(where=where)
        self.assertEqual(1, results)
示例#16
0
    def test_update(self):
        args = {'first_name': "a", "last_name": "b", "age": 10}
        u = yield User(**args).save()

        args = {'first_name': "b", "last_name": "a", "age": 100}
        for key, value in args.items():
            setattr(u, key, value)
        yield u.save()

        u = yield User.find(u.id)
        for key, value in args.items():
            self.assertEqual(getattr(u, key), value)
示例#17
0
    def setUp(self):
        dir_path = os.path.dirname(os.path.realpath(__file__))
        self.USER_GNUPGHOME = tempfile.TemporaryDirectory(prefix=dir_path + "/secrets/")
        self.ADMIN_GNUPGHOME = tempfile.TemporaryDirectory(prefix=dir_path + "/secrets/")
        relative_user = "******" + self.USER_GNUPGHOME.name.split(dir_path)[1]
        relative_admin = "." + self.ADMIN_GNUPGHOME.name.split(dir_path)[1]
        config = ConfigParser()
        config.read_string(
            """
            [ca]
            key = secrets/certs/authority/RootCA.key
            cert = secrets/certs/authority/RootCA.pem
            issuer = My Company Name
            alternate_name = *.myname.com

            [gnupg]
            user={user_gnupghome}
            admin={admin_gnupghome}

            [storage]
            engine=sqlite3

            [storage.sqlite3]
            db_path=:memory:
            """.format(
                user_gnupghome=relative_user, admin_gnupghome=relative_admin
            )
        )
        self.common_name = "user@host"
        self.key = generate_key()
        self.engine = storage.SQLiteStorageEngine(config)
        cur = self.engine.conn.cursor()
        cur.execute("DROP TABLE IF EXISTS certs")
        self.engine.conn.commit()
        self.engine.init_db()
        self.cert_processor = CertProcessor(config)
        self.user_gpg = gnupg.GPG(gnupghome=self.USER_GNUPGHOME.name)
        self.admin_gpg = gnupg.GPG(gnupghome=self.ADMIN_GNUPGHOME.name)
        self.users = [
            User("user@host", gen_passwd(), generate_key(), gpg=self.user_gpg),
            User("user2@host", gen_passwd(), generate_key(), gpg=self.user_gpg),
            User("user3@host", gen_passwd(), generate_key(), gpg=self.user_gpg),
        ]
        self.invalid_users = [
            User("user4@host", gen_passwd(), generate_key(), gpg=self.user_gpg)
        ]
        self.admin_users = [
            User("admin@host", gen_passwd(), generate_key(), gpg=self.admin_gpg)
        ]
        for user in self.users:
            self.user_gpg.import_keys(self.user_gpg.export_keys(user.fingerprint))
        for user in self.admin_users:
            self.admin_gpg.import_keys(self.admin_gpg.export_keys(user.fingerprint))
示例#18
0
    def setUp(self):
        self.USER_GNUPGHOME = tempfile.TemporaryDirectory()
        self.ADMIN_GNUPGHOME = tempfile.TemporaryDirectory()
        self.AUTHORITY_FOLDER = tempfile.TemporaryDirectory()
        config = ConfigParser()
        config.read_string(
            """
            [ca]
            key = {authority_folder}/RootCA.key
            cert = {authority_folder}/RootCA.pem
            issuer = My Company Name
            alternate_name = *.myname.com

            [gnupg]
            user={user_gnupghome}
            admin={admin_gnupghome}

            [storage]
            engine=sqlite3

            [storage.sqlite3]
            db_path=:memory:
            """.format(
                user_gnupghome=self.USER_GNUPGHOME.name,
                admin_gnupghome=self.ADMIN_GNUPGHOME.name,
                authority_folder=self.AUTHORITY_FOLDER.name,
            )
        )
        self.common_name = "user@host"
        self.key = generate_key()
        self.engine = storage.SQLiteStorageEngine(config)
        cur = self.engine.conn.cursor()
        cur.execute("DROP TABLE IF EXISTS certs")
        self.engine.conn.commit()
        self.engine.init_db()
        self.cert_processor = CertProcessor(config)
        self.user_gpg = gnupg.GPG(gnupghome=self.USER_GNUPGHOME.name)
        self.admin_gpg = gnupg.GPG(gnupghome=self.ADMIN_GNUPGHOME.name)
        self.users = [
            User("user@host", gen_passwd(), generate_key(), gpg=self.user_gpg),
            User("user2@host", gen_passwd(), generate_key(), gpg=self.user_gpg),
            User("user3@host", gen_passwd(), generate_key(), gpg=self.user_gpg),
        ]
        self.invalid_users = [
            User("user4@host", gen_passwd(), generate_key(), gpg=self.user_gpg)
        ]
        self.admin_users = [
            User("admin@host", gen_passwd(), generate_key(), gpg=self.admin_gpg)
        ]
        for user in self.users:
            self.user_gpg.import_keys(self.user_gpg.export_keys(user.fingerprint))
        for user in self.admin_users:
            self.admin_gpg.import_keys(self.admin_gpg.export_keys(user.fingerprint))
示例#19
0
    def test_joinWheres_precedence(self):
        yield User(first_name="Second").save()

        first = ['first_name = ?', "First"]
        last = ['last_name = ?', "Last"]
        second = ['first_name = ?', "Second"]

        last_or_second = utils.joinWheres(last, second, joiner='OR')
        where = utils.joinWheres(first, last_or_second, joiner='AND')

        results = yield User.count(where=where)
        self.assertEqual(1, results)
示例#20
0
    def test_select(self):
        # make a fake user
        user = yield User(first_name="Another First").save()
        tablename = User.tablename()

        where = ['first_name = ?', "First"]
        result = yield self.dbconfig.select(tablename, where=where, limit=1, orderby="first_name ASC")
        self.assertTrue(result is not None)
        self.assertEqual(result['id'], self.user.id)

        result = yield self.dbconfig.select(tablename, limit=100, orderby="first_name ASC")
        self.assertEqual(len(result), 2)
        self.assertTrue(result[0]['id'] == user.id and result[1]['id'] == self.user.id)
示例#21
0
    def test_update_obj(self):
        args = {'first_name': "test_insert_obj", "last_name": "foo", "age": 91}
        user = yield User(**args).save()

        args = {'first_name': "test_insert_obj_foo", "last_name": "bar", "age": 191}
        for key, value in args.items():
            setattr(user, key, value)

        yield self.dbconfig.updateObj(user)
        user = yield User.find(user.id)

        for key, value in args.items():
            self.assertEqual(value, getattr(user, key))
示例#22
0
    def test_insert_obj(self):
        args = {'first_name': "test_insert_obj", "last_name": "foo", "age": 91}
        user = User(**args)

        saved = yield self.dbconfig.insertObj(user)
        user = yield User.find(where=['first_name = ?', "test_insert_obj"], limit=1)
        # ensure that id was set on save
        self.assertEqual(saved.id, user.id)
        # and all values are still the same
        self.assertEqual(saved, user)

        for key, value in args.items():
            self.assertEqual(value, getattr(user, key))
示例#23
0
    def test_insert_many(self):
        tablename = User.tablename()

        args = []
        for counter in range(10):
            args.append({'first_name': "test_insert_many", "last_name": "foo", "age": counter})
        yield self.dbconfig.insertMany(tablename, args)

        users = yield User.find(where=['first_name = ?', "test_insert_many"], orderby="age ASC")

        for counter in range(10):
            for key, value in args[counter].items():
                self.assertEqual(value, getattr(users[counter], key))
示例#24
0
    def test_insert(self):
        tablename = User.tablename()
        args = {'first_name': "test", "last_name": "foo", "age": 91}
        id = yield self.dbconfig.insert(tablename, args)

        where = ['first_name = ? AND last_name = ? AND age = ?']
        where = where + ["test", "foo", 91]
        users = yield User.find(where=where)

        self.assertEqual(len(users), 1)
        self.assertEqual(users[0].id, id)
        for key, value in args.items():
            self.assertEqual(value, getattr(users[0], key))
示例#25
0
    def test_insert(self):
        tablename = User.tablename()
        args = {'first_name': "test", "last_name": "foo", "age": 91}
        id = yield self.dbconfig.insert(tablename, args)

        where = ['first_name = ? AND last_name = ? AND age = ?']
        where = where + ["test", "foo", 91]
        users = yield User.find(where=where)

        self.assertEqual(len(users), 1)
        self.assertEqual(users[0].id, id)
        for key, value in args.items():
            self.assertEqual(value, getattr(users[0], key))
示例#26
0
    def test_beforeDelete(self):
        User.beforeDelete = lambda user: False
        u = yield User().save()
        oldid = u.id
        yield u.delete()
        result = yield User.find(oldid)
        self.assertEqual(result, u)

        User.beforeDelete = lambda user: True
        yield u.delete()
        result = yield User.find(oldid)
        self.assertEqual(result, None)

        # restore user's beforeDelete
        User.beforeDelete = DBObject.beforeDelete
    def register(self, conn, user_name):
        '''register new user, and  login the user'''
        if user_name in users:
            self.__send_data_close(conn, usr_exist)
            return False

        user = User(username=user_name)
        user.login(conn)

        users[user_name] = user
        conn_user_map[conn] = user
        token_user_map[user.token] = user
        self.__send_data(conn=conn, info=info_ok, kind=kind_register, token=user.token)

        return True
示例#28
0
文件: basebot.py 项目: daringer/horst
    def on_join(self, c, e):
        """Hook for someone joining the channel (/join).
        --> e.target() == channel 
        --> e.source() == nick!~user@hostname
        """
        nick, channame, hostname = nm_to_n(
            e.source()), e.target().lower(), nm_to_h(e.source())
        if self.nick != nick:
            chan = self.chans[channame]

            self.users[nick] = user = User(nick, hostname, self.connection) if \
                not nick in self.users else self.users[nick]

            user.channels += [chan]
            chan.users += [user]

            data = Data(line_raw=nick,
                        reaction_type="join",
                        chan=chan,
                        user=user)
            self.dispatch(data)
        else:
            self.chans[channame] = chan = Channel(channame, self.connection)
            data = Data(line_raw=channame,
                        reaction_type="enter_channel",
                        chan=chan)
            self.dispatch(data)
示例#29
0
def new_external_order():
    if request.method == 'POST':
        data = request.form.to_dict()
        try:
            scenelist = data['input_product_list']
            _u, _p = base64.b64decode(data['user']).split(':')
            resp_json = api_get('/user', uauth=(_u, _p))
            if 'username' in resp_json:
                session['logged_in'] = True
                resp_json['wurd'] = _p
                session['user'] = User(**resp_json)
            else:
                logger.info(
                    '*** Failed external order user login: {}'.format(_u))
                return jsonify({'msg': 'user auth failed'}), 401
        except KeyError:
            return jsonify({
                'error':
                "'input_product_list' and 'user' fields are required"
            }), 401
        except Exception as e:
            logger.info(
                "*** espa-web exception - problem parsing external order request. message: {}"
                .format(e.message))
            return jsonify({'error': 'problem parsing request'}), 400
    else:
        # GET redirect from ESPA after order validation
        scenelist = session['ipl']

    return render_template('new_order.html',
                           form_action=url_for('submit_order'),
                           scenelist=scenelist)
示例#30
0
 def log_out(self, message_content):
     user_to_remove = message_content.get(MessageFields.SENDER_USERNAME)
     if user_to_remove:
         self.users_dict[user_to_remove] = User(None, None, False)
         print("Went offline: {}".format(user_to_remove))
     else:
         warnings.warn('no such user exists')
示例#31
0
def setup_test_context(request):
    recipient = User(
        email=request.config.getoption('--recipient'),
        password=request.config.getoption('--recipient_password')
    )
    sender = User(
        email=request.config.getoption('--sender'),
        password=request.config.getoption('--sender_password')
    )

    return SetupConfig(
        recipient=recipient,
        sender=sender,
        imap_endpoint=TestSettings.imap_endpoint,
        smtp_endpoint=TestSettings.smtp_endpoint
    )
示例#32
0
    def test_select_id(self):
        tablename = User.tablename()

        result = yield self.dbconfig.select(tablename, self.user.id, where=None, limit=1, orderby="first_name ASC")
        self.assertTrue(result is not None)

        where = ['first_name = ?', "DNE"]
        result = yield self.dbconfig.select(tablename, self.user.id, where=where, limit=1, orderby="first_name ASC")
        self.assertTrue(result is None)
示例#33
0
    def test_validation(self):
        User.validatesPresenceOf('first_name', message='cannot be blank, fool.')
        User.validatesLengthOf('last_name', range=xrange(1, 101))
        User.validatesUniquenessOf('first_name')

        u = User()
        yield u.validate()
        self.assertEqual(len(u.errors), 2)

        first = yield User(first_name="not unique", last_name="not unique").save()
        u = yield User(first_name="not unique", last_name="not unique").save()
        self.assertEqual(len(u.errors), 1)
        self.assertEqual(u.id, None)

        # make sure first can be updated
        yield first.save()
        self.assertEqual(len(first.errors), 0)
        User.clearValidations()
示例#34
0
    def test_update(self):
        tablename = User.tablename()
        user = yield User(first_name="Another First").save()

        args = {'first_name': "test", "last_name": "foo", "age": 91}
        yield self.dbconfig.update(tablename, args, ['id = ?', user.id])
        yield user.refresh()
        for key, value in args.items():
            self.assertEqual(value, getattr(user, key))
示例#35
0
    def test_afterInit(self):
        def afterInit(user):
            user.blah = "foobar"
        User.afterInit = afterInit
        u = yield User.find(limit=1)
        self.assertTrue(hasattr(u, 'blah'))
        self.assertEqual(u.blah, 'foobar')

        # restore user's afterInit
        User.afterInit = DBObject.afterInit
示例#36
0
    def test_joinMultipleWheres(self):
        yield User(first_name="First", last_name="Last", age=20).save()

        first = ['first_name = ?', "First"]
        last = ['last_name = ?', "Last"]
        age = ['age <> ?', 20]

        where = utils.joinMultipleWheres([first, last, age], joiner='AND')

        results = yield User.count(where=where)
        self.assertEqual(1, results)
示例#37
0
    def test_joinWheres_precedence(self):
        yield User(first_name="Second").save()

        first = ['first_name = ?', "First"]
        last = ['last_name = ?', "Last"]
        second = ['first_name = ?', "Second"]

        last_or_second = utils.joinWheres(last, second, joiner='OR')
        where = utils.joinWheres(first, last_or_second, joiner='AND')

        results = yield User.count(where=where)
        self.assertEqual(1, results)
示例#38
0
    def test_loadRelations(self):
        user = yield User.find(limit=1)
        all = yield user.loadRelations()

        pictures = yield user.pictures.get()
        self.assertEqual(pictures, all['pictures'])

        avatar = yield user.avatar.get()
        self.assertEqual(avatar, all['avatar'])

        suball = yield user.loadRelations('pictures')
        self.assertTrue('avatar' not in suball)
        self.assertEqual(pictures, suball['pictures'])
示例#39
0
    def test_clear_has_many(self):
        pics = [self.picture]
        for _ in range(3):
            pic = yield Picture(name="a pic").save()
            pics.append(pic)

        yield self.user.pictures.set(pics)
        yield self.user.pictures.clear()

        userpics = yield self.user.pictures.get()
        self.assertEqual(userpics, [])

        # even go so far as to refetch user
        yield User.find(self.user.id)
        userpics = yield self.user.pictures.get()
        self.assertEqual(userpics, [])

        # picture records should be updated
        pics = yield Picture.find(where=["user_id=?", self.user.id])
        self.assertEqual(pics, [])

        # but still exist
        pics = yield Picture.all()
        self.assertEqual(len(pics), 4)
示例#40
0
    def test_findBy(self):
        r = yield User.findBy(first_name="Non", last_name="Existant")
        self.assertEqual(r, [])

        r = yield User.findBy(first_name="First", last_name="Last", age=11)
        self.assertEqual(r, [])

        r = yield User.findBy(first_name="First", last_name="Last", age=10)
        self.assertEqual(r[0], self.user)

        r = yield User.findBy(first_name="First", last_name="Last")
        self.assertEqual(r[0], self.user)

        yield User(first_name="Bob").save()
        r = yield User.findBy()
        self.assertEqual(len(r), 2)

        yield User(first_name=None).save()
        r = yield User.findBy(first_name=None)
        self.assertEqual(len(r), 1)
示例#41
0
 def __init__(self):
   self.users = User.query().fetch(10)
示例#42
0
 def test_delete(self):
     u = yield User().save()
     oldid = u.id
     yield u.delete()
     result = yield User.find(oldid)
     self.assertEqual(result, None)
示例#43
0
    def test_validation_function(self):
        def adult(user):
            if user.age < 18:
                user.errors.add('age', "must be over 18.")
        User.addValidator(adult)

        u = User(age=10)
        valid = yield u.isValid()
        self.assertEqual(valid, False)
        yield u.save()
        self.assertEqual(len(u.errors), 1)
        self.assertEqual(len(u.errors.errorsFor('age')), 1)
        self.assertEqual(len(u.errors.errorsFor('first_name')), 0)
        User.clearValidations()

        u = User(age=10)
        valid = yield u.isValid()
        self.assertEqual(valid, True)
        User.clearValidations()