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)
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)
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)
]
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))
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))
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))
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)
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)
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')
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'))
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
)
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)
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(
seed_dir=self.SEED_DIR.name,
user_gnupghome=self.USER_GNUPGHOME.name,
admin_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)
]
def __init__(self, ):
"""
"""
upw = User().get_user_pwd('7958')
self.driver = webdriver.Firefox()
self.base_url = "http://www.7958.com"
self.user = upw[0]
self.password = upw[1]
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)
def __init__(self, driver=None):
"""
"""
upw = User().get_user_pwd('yiyipan')
self.driver = driver if driver else webdriver.Firefox(get_firefox_profile())
self.base_url = "http://www.yiyipan.com"
self.user = upw[0]
self.password = upw[1]
def test_creation(self):
# test creating blank object
u = yield User().save()
self.assertTrue(type(u.id) == int or type(u.id) == long)
# test creating object with props that don't correspond to columns
u = yield User(a_fake_column="blech").save()
self.assertTrue(type(u.id) == int or type(u.id) == long)
# Test table doesn't exist
f = FakeObject(blah="something")
self.failUnlessFailure(f.save(), ImaginaryTableError)
dateklass = Registry.getDBAPIClass("Date")
args = {'first_name': "a", "last_name": "b", "age": 10, "dob": dateklass(2000, 1, 1)}
u = yield User(**args).save()
for key, value in args.items():
self.assertEqual(getattr(u, key), value)
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)
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)
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()
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))
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)
def test_clear_habtm(self):
user = yield User().save()
color = yield FavoriteColor(name="red").save()
colors = [self.favcolor, color]
yield user.favorite_colors.set(colors)
yield user.favorite_colors.clear()
colors = yield user.favorite_colors.get()
self.assertEqual(colors, [])
def setUp(self):
yield initDB(self)
self.user = yield User(first_name="First", last_name="Last",
age=10).save()
self.avatar = yield Avatar(name="an avatar name",
user_id=self.user.id).save()
self.picture = yield Picture(name="a pic",
size=10,
user_id=self.user.id).save()
self.dbconfig = Registry.getConfig()
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
def test_set_habtm_blank(self):
user = yield User().save()
color = yield FavoriteColor(name="red").save()
colors = [self.favcolor, color]
yield user.favorite_colors.set(colors)
# now blank out
yield user.favorite_colors.set([])
newcolors = yield user.favorite_colors.get()
self.assertEqual(len(newcolors), 0)
def test_set_habtm(self):
user = yield User().save()
color = yield FavoriteColor(name="red").save()
colors = [self.favcolor, color]
colorids = [c.id for c in colors]
yield user.favorite_colors.set(colors)
newcolors = yield user.favorite_colors.get()
newcolorids = [c.id for c in newcolors]
self.assertEqual(newcolorids, colorids)
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()
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)
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)
