def test_referrals(referrals):
A = User(0)
B = User(1)
Referral().set_referral(referee=B, referrer=A)
assert len(Referral.referrals) == 1
def test_find_user_by_student_num():
me = InventoryManager()
bill = User("*****@*****.**", 123456789)
shaquiffa = User("*****@*****.**", 987654321)
assert me.find_user_by_student_num(123456789) == bill
assert me.find_user_by_student_num(987654321) == shaquiffa
def test_user_refer_a_referrer_with_referees(referrals):
A = User(0)
B = User(1)
C = User(2)
Referral().set_referral(referee=B, referrer=A)
Referral().set_referral(referee=A, referrer=C)
assert len(Referral.referrals) == 2
def test_user_refer_his_referrer(referrals):
A = User(0)
B = User(1)
Referral().set_referral(referee=B, referrer=A)
with pytest.raises(CircularRefer):
Referral().set_referral(referee=A, referrer=B)
assert len(Referral.referrals) == 1
def test_user_refer_a_user_with_referrer(referrals):
A = User(0)
B = User(1)
C = User(2)
Referral().set_referral(referee=B, referrer=A)
with pytest.raises(RefereeIsAlreadyReferred):
Referral().set_referral(referee=B, referrer=C)
assert len(Referral.referrals) == 1
def test_circular_refer_with_four_levels(referrals):
A = User(0)
B = User(1)
C = User(2)
D = User(3)
users = [A, B, C, D]
Referral().set_referral(referee=B, referrer=A)
Referral().set_referral(referee=C, referrer=B)
Referral().set_referral(referee=D, referrer=C)
with pytest.raises(CircularRefer):
Referral().set_referral(referee=A, referrer=D)
assert len(Referral.referrals) == len(users) - 1
def test_sign_out():
me = InventoryManager()
user_a = User("*****@*****.**", 12344)
user_b = User("*****@*****.**", 12344)
bin_a = Bin("A1", 12345)
bin_b = Bin("B1", 41325)
part_a = Part("motor", 2, "1j343g", bin_a.id)
part_b = Part("sensor", 10, "4h935y", bin_b.id)
me.sign_out(part_a, 2, user_a)
assert bin_a.qty_in_bin == 0
assert len(me.logs) == 1
me.sign_out(part_b, 4, user_b)
assert bin_b.qty_in_bin == 6
assert len(me.logs) == 2
def register(name=None):
""" Adds a new user to the wishlist user base"""
title="Register"
error=None
if request.method == "GET":
return render_template("register.html",title=title)
if request.method == "POST":
print "method is post"
if request.form['firstname']=="" or request.form['lastname'] =="" or request.form['email']=="" or request.form['password'] =="" or request.form['password_conf'] =="":
error="Invalid User Info Supplied"
print error
else:
try:
if request.form['password'] !=request.form['password_conf']:
error ="passwords dont match"
else:
created_user = User(request.form['firstname'].upper(),request.form['lastname'].upper(),request.form['email'].lower(),request.form['password'].upper())
conn = sqlite3.connect(app.config['DATABASE'])
if conn is not None:
cur = conn.cursor()
cur.execute("SELECT * from wishlist_users where email=?",(created_user.email))
row = cur.fetchone()
if row is None:
cur.execute("INSERT INTO wishlist_users (firstname,lastname,email,password) VALUES (?,?,?,?)", (created_user.firstname, created_user.lastname, created_user.email, created_user.password) )
conn.commit()
else:
raise ValueError
print created_user.firstname
error= "User Created Successfully! Please go to login page"
except:
error="Registration Failed"
return render_template("register.html",title=title,error=error)
def testSignUpHandlerBADSTUDENTPost2(self, mock):
# Arrange: Make the web request with all of the necessary information.
test_user = User()
test_user.email = "*****@*****.**"
test_user.password = "******"
test_user.put()
test_request = webapp2.Request.blank('/signup',
POST={
"firstname": "TESTFIRST",
"lastname": "TESTLAST",
"email":
"*****@*****.**",
"password": "******",
"b9": "COMPSCI101"
})
main.isInstructor = False
test_request.method = 'POST'
mock.return_value = None
# Act
response = test_request.get_response(main.app)
# Assert: Inspect the response
self.assertTrue(main.error != '')
mock.assert_called_with('/signup')
def test_db_read_write(client):
assert User.query.filter_by(user_id=test_user_id).first() == None
db.session.add(
User(user_id=test_user_id,
user_name=test_user_name,
user_password=test_user_password))
db.session.commit()
assert User.query.filter_by(user_id=test_user_id).first() != None
assert Thread.query.filter_by(thread_id=test_thread_id).first() == None
db.session.add(
Thread(thread_id=test_thread_id, thread_name=test_thread_name))
db.session.commit()
assert Thread.query.filter_by(thread_id=test_thread_id).first() != None
assert Subscription.query.filter_by(
subscription_id=test_subscription_id).first() == None
db.session.add(
Subscription(subscription_id=test_subscription_id,
user_id=test_user_id,
thread_id=test_thread_id))
db.session.commit()
assert Subscription.query.filter_by(
subscription_id=test_subscription_id).first() != None
delete_subscription(test_subscription_id)
delete_user(test_user_id)
delete_thread(test_thread_id)
def quit(self):
global a
a=a+1
print(" THANK YOU ")
from main import User
user1=User()
user1.customer(CusId)
def create_user():
try:
app.users.append(User(**user_schema.load(request.json)))
response.status = 201
return user_schema.dumps(app.users[-1])
except ValidationError as error:
response.status = 400
return {"error": str(error)}
def create_user():
db.create_all()
admin = User(id=0, username='******', password_hash= pwd_context.encrypt("admin"))
print("Created user")
print("Login: admin")
print("Password: admin")
db.session.add(admin)
db.session.commit()
def setUp(self):
db.create_all()
db.session.add(
User(id=1,
Name="",
Email="*****@*****.**",
Username="******",
Password="******"))
db.session.commit()
def test_account_exist(self):
'''
method to check whether the account details of the User exist
'''
self.new_user.save_user_info()
test_user = User("Twitter", "Diane", "dee420")
test_user.save_user_info()
user_exists = User.account_exists("Twitter")
self.assertTrue(user_exists)
def get_users(from_path):
users = []
with open(from_path, 'r') as file:
for row in csv.reader(file):
user_id = int(row[0])
username = row[1]
member_since = datetime.strptime(
row[2], '%Y-%m-%d') if row[2] is not '' else None
users.append(User(user_id, username, member_since))
return sorted(users, key=lambda u: u.id)
def addFarm():
farm = User(farmname=user['farmname'],
address=user['coordinates'],
farmtype=user['farmtype'],
about=user['about'],
username=user['username'],
password=user['password'],
date_created=user['date'])
db.session.add(farm)
db.session.commit()
def test_find_by_account_name(self):
'''
Test case to test whether a user can find their account by account_name
'''
self.new_user.save_user_info()
test_user = User("Twitter", "Diane", "dee420")
test_user.save_user_info()
user_found = User.find_by_account_name("Twitter")
self.assertEqual(user_found.username, test_user.username)
def test_circular_refer_with_thousand_levels(referrals):
users = [User(i) for i in range(1000)]
[
Referral().set_referral(referee=users[i + 1], referrer=users[i])
for i in range(len(users))
if i < len(users) - 1
]
with pytest.raises(CircularRefer):
Referral().set_referral(referee=users[0], referrer=users[-1])
def test_get_user_info(self):
user = User(name='Vladimir', age=34)
db.session.add(user)
db.session.commit()
with app.test_client() as client:
response = json.loads(client.get('/user').data.decode('utf-8'))
first = response[0]
self.assertEqual(first['name'], user.name)
self.assertEqual(first['age'], user.age)
self.assertIsNotNone(first['register_date'])
self.assertIsNotNone(first['last_activity'])
def test_delete_user(self):
'''
Method to test whether we can delete a user from our user's list
'''
self.new_user.save_user()
test_user = User("Jadiel", "Muriithi", "0727867684",
"*****@*****.**", "sirmwas",
"101010") #new user
test_user.save_user()
self.new_user.delete_user() #Deleting a user
self.assertEqual(len(User.user_list), 1)
def insertar(numero):
print("va a isertar el dato")
user4 = User(username='******' + str(numero))
db.session.add(user4)
try:
db.session.commit()
except:
db.session.rollback()
raise
finally:
db.session.close() # optional, depends on use case
def testLoginHandlerCookieFaculty(self, mock):
user = User()
user.Fname = "Matt"
user.Lname = "K"
user.email = "*****@*****.**"
user.password = "******"
user.isInstructor = True
main.u = user
user.put()
request = webapp2.Request.blank('/login')
request.cookies['uname'] = "*****@*****.**"
response = request.get_response(main.app)
mock.assert_called_with('Faculty_landing.html')
def generate_users(n):
users = list()
for i in range(n):
user = User(faker.name())
user.username = faker.name()
user.password = "******"
try:
db.session.add(user)
db.session.commit()
users.append(user)
except Exception as e:
log.error("Fail to add user %s: %s" % (str(user), e))
db.session.rollback()
return users
def test_return_part():
me = InventoryManager()
bin = Bin("C1", 123456)
part = Part("wloo cs coop", 10, "kljhee", bin.id)
user = User("*****@*****.**", 59487162)
me.sign_out(part, 8, user)
me.return_part(part, 4, user)
assert bin.qty_in_bin == 6
assert len(me.logs) == 4
me.return_part(part, 2, user)
assert bin.qty_in_bin == 8
assert len(me.logs) == 5
def main():
user = User('John', 'password', '*****@*****.**', '12/25/1999')
print(user.username)
print(user.password)
print(user)
print()
print(repr(user))
user2 = User("John", "password", "*****@*****.**", "12/25/1999")
print(user == user2)
print(user.check_password('1234'))
user.username = '******'
print(user.username)
superuser = SuperUser('jon', 'password', '*****@*****.**', '12/24/1999',
'admin')
print(superuser)
print()
print(repr(superuser))
print('ran demo.main')
def main():
"""Main entry point for script."""
with app.app_context():
print("Creating metadata")
db.metadata.create_all(db.engine)
print("done")
print('Enter username: '******'Password (again):')
print("Enter clearance level")
clearance = input()
user = User(username=username,
password=bcrypt.generate_password_hash(password),
clearance=clearance,
role="user")
db.session.add(user)
db.session.commit()
print('User added.')
def testMainHandlerCookie(self, mock_set_cookie, mock_redir):
user = User()
user.Fname = "Matt"
user.Lname = "K"
user.email = "*****@*****.**"
user.password = "******"
user.put()
request = webapp2.Request.blank('/home',
POST={
"user_email": "*****@*****.**",
"pass_word": "KMatt"
})
request.method = 'POST'
mock_redir.return_value = None
response = request.get_response(main.app)
mock_set_cookie.assert_called_with('uname', user.email, path='/')
self.assertEqual(main.error, "")
mock_redir.assert_called_with('/login')
def testMainHandlerPostPWError(self, mock):
# Arrange: Put a User in the datastore stub; POST the wrong password.
test_User = User()
test_User.email = "*****@*****.**"
test_User.password = "******"
test_User.put()
test_request = webapp2.Request.blank('/home',
POST={
"user_email":
"*****@*****.**",
"pass_word": "WRONGPASSWORD"
})
test_request.method = 'POST'
mock.return_value = None
# Act: Give the request to the app.
response = test_request.get_response(main.app)
# Assert: Inspect the response.
mock.assert_called_with('/home')
self.assertEqual(main.error, "Incorrect password!")
def setUp(self):
class TestConfig(object):
SQLALCHEMY_DATABASE_URI = 'sqlite://'
DEBUG = True
TESTING = True
app.config.from_object(TestConfig())
self.app = app
with self.app.test_request_context():
db.create_all()
raw_users = [{
'username': '******',
'email': '*****@*****.**',
'password': '******'
}, {
'username': '******',
'email': '*****@*****.**',
'password': '******'
}, {
'username': '******',
'email': '*****@*****.**',
'password': '******'
}]
raw_groups = [{
'name': 'group1'
}, {
'name': 'group2'
}, {
'name': 'group3'
}]
for user in raw_users:
password = user.pop('password')
user = User(**user)
user.set_password(password)
user.save()
for group in raw_groups:
Group(**group).save()
