def test_user_login(self):
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='volunteer',
location='nashville')
schema = UserSchema()
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.')
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
login_response = self.client.post('/users/login',
data=schema.dumps(user).data,
content_type='application/json')
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
def test_fdc_can_be_edited(self):
"""Test API can edit an existing DC. (PUT request)"""
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='fdcAdmin',
location='nashville')
schema = UserSchema()
#Register a new FDC Admin
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.')
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
#Login as FDC Admin
login_response = self.client.post('/users/login',
data=schema.dumps(user).data,
content_type='application/json')
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
fdc_schema = FDCSchema()
creation_response = self.client.post(
'/fdcs/',
data=fdc_schema.dumps(self.fdc).data,
headers=dict(Authorization='Bearer ' + login_data['auth_token']),
content_type='application/json')
creation_data = json.loads(creation_response.data.decode())
self.assertTrue(creation_data['status'] == 'success')
self.assertTrue(
creation_data['message'] == 'Successfully created FDC.')
self.assertTrue(creation_response.content_type == 'application/json')
self.assertEqual(creation_response.status_code, 201)
put_response = self.client.put('/fdcs/1',
headers=dict(Authorization='Bearer ' +
login_data['auth_token']),
data={'name': 'Wendys'},
content_type='application/json')
print(put_response.data)
self.assertEqual(put_response.status_code, 200)
results = self.client().get('/fdcs/1')
self.assertIn('Wendys', str(results.data))
def test_dc_deletion(self):
"""Test API can delete an existing fdc. (DELETE request)."""
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='fdcAdmin',
location='nashville')
schema = UserSchema()
#Register a new FDC Admin
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.')
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
#Login as FDC Admin
login_response = self.client.post('/users/login',
data=schema.dumps(user).data,
content_type='application/json')
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
fdc_schema = FDCSchema()
creation_response = self.client.post(
'/fdcs/',
data=fdc_schema.dumps(self.fdc).data,
headers=dict(Authorization='Bearer ' + login_data['auth_token']),
content_type='application/json')
creation_data = json.loads(creation_response.data.decode())
self.assertTrue(creation_data['status'] == 'success')
self.assertTrue(
creation_data['message'] == 'Successfully created FDC.')
self.assertTrue(creation_response.content_type == 'application/json')
self.assertEqual(creation_response.status_code, 201)
res = self.client.delete('/fdcs/1',
headers=dict(Authorization='Bearer ' +
login_data['auth_token']))
self.assertEqual(res.status_code, 200)
# Test to see if it exists, should return a 404
result = self.client().get('/fdcs/1')
self.assertEqual(result.status_code, 404)
def test_api_can_get_all_fdc(self):
"""Test API can get a FDC (GET request)."""
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='fdcAdmin',
location='nashville')
schema = UserSchema()
#Register a new FDC Admin
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.')
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
#Login as FDC Admin
login_response = self.client.post('/users/login',
data=schema.dumps(user).data,
content_type='application/json')
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
fdc_schema = FDCSchema()
creation_response = self.client.post(
'/fdcs/',
data=fdc_schema.dumps(self.fdc).data,
headers=dict(Authorization='Bearer ' + login_data['auth_token']),
content_type='application/json')
creation_data = json.loads(creation_response.data.decode())
self.assertTrue(creation_data['status'] == 'success')
self.assertTrue(
creation_data['message'] == 'Successfully created FDC.')
self.assertTrue(creation_response.content_type == 'application/json')
self.assertEqual(creation_response.status_code, 201)
get_response = self.client.get('/fdcs/')
data = json.loads(get_response.data.decode())
self.assertTrue(data['status'] == 'success')
self.assertIn('Nashville Food Project', str(data['fdcs']))
self.assertEqual(get_response.status_code, 200)
def test_pickup_accept:
#User we're using
user = User(username='******', email='*****@*****.**', password='******', first_name='charlie', last_name='fei', role='donor', location='nashville')
volunteer = User(username='******', email='*****@*****.**', password='******', first_name='vol', last_name='fei', role='volunteer', location='nashville')
schema = UserSchema()
#Register User
register_response = self.client.post('/users/',
data = schema.dumps(user).data,
content_type = 'application/json'
)
registration_data = json.loads(register_response.data.decode())
self.assertTrue(registration_data['status'] == 'success')
self.assertTrue(
registration_data['message'] == 'Successfully registered.'
)
self.assertTrue(registration_data['auth_token'])
self.assertTrue(register_response.content_type == 'application/json')
self.assertEqual(register_response.status_code, 201)
#Login User
login_response = self.client.post('/users/login',
data = schema.dumps(user).data,
content_type = 'application/json'
)
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'success')
self.assertTrue(login_data['message'] == 'Successfully logged in.')
self.assertTrue(login_data['auth_token'])
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 200)
pickup_schema = PickupSchema()
pickup = Pickup(description="My Pickup", donor=user)
creation_response = self.client.post('/users/charlie/pickups/',
data = pickup_schema.dumps(pickup).data,
headers=dict(
Authorization='Bearer ' + login_data['auth_token']
),
content_type = 'application/json'
)
creation_data = json.loads(creation_response.data.decode())
self.assertTrue(creation_data['status'] == 'success')
self.assertTrue(creation_data['message'] == 'Successfully created pickup.')
self.assertTrue(creation_response.content_type == 'application/json')
self.assertEqual(creation_response.status_code, 201)
def post(self):
"""
Create New User
"""
user_schema = UserSchema()
user_data = request.get_json()
# Validate user data
validated_user_data, errors = user_schema.load(user_data)
if errors:
return dict(status="fail", message=errors), 400
email = validated_user_data.get('email', None)
# Check if user email exists
user_existant = User.query.filter_by(email=email).first()
if user_existant:
return dict(status="fail", message=f"Email {validated_user_data['email']} already in use."), 400
# add validated data to user object
user = User(**validated_user_data)
saved_user = user.save()
if not saved_user:
return dict(status='fail', message=f'Internal Server Error'), 500
# for returning to user
new_user_data, errors = user_schema.dumps(user)
return dict(status='success', data=dict(user=json.loads(new_user_data))), 201
def test_user_get_info(self):
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='volunteer',
location='nashville')
schema = UserSchema()
register_response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
register_data = json.loads(register_response.data.decode())
get_response = self.client.get(
'/users/' + user.username,
headers=dict(Authorization='Bearer ' +
register_data['auth_token']))
data = json.loads(get_response.data.decode())
self.assertTrue(data['status'] == 'success')
self.assertTrue(data['data'] is not None)
self.assertTrue(data['data']['username'] == 'charlie')
self.assertTrue(data['data']['email'] == '*****@*****.**')
self.assertTrue(data['data']['first_name'] == 'charlie')
self.assertTrue(data['data']['last_name'] == 'fei')
self.assertTrue(data['data']['role'] == 'volunteer')
def post(self):
"""
"""
user_schema = UserSchema()
user_data = request.get_json()
validated_user_data, errors = user_schema.load(user_data)
email = validated_user_data.get('email', None)
client_base_url = os.getenv('CLIENT_BASE_URL',
f'https://{request.host}/users')
# To do change to a frontend url
verification_url = f"{client_base_url}/verify/"
secret_key = current_app.config["SECRET_KEY"]
password_salt = current_app.config["VERIFICATION_SALT"]
sender = current_app.config["MAIL_DEFAULT_SENDER"]
template = "user/verify.html"
subject = "Please confirm your email"
if errors:
return dict(status="fail", message=errors), 400
# get the customer role
user_role = Role.find_first(name='customer')
user_existant = User.query.filter_by(email=email).first()
if user_existant:
return dict(
status="fail",
message=f"Email {validated_user_data['email']} already in use."
), 400
user = User(**validated_user_data)
if user_role:
user.roles.append(user_role)
saved_user = user.save()
if not saved_user:
return dict(status='fail', message=f'Internal Server Error'), 500
# send verification
send_verification(email, user.name, verification_url, secret_key,
password_salt, sender,
current_app._get_current_object(), template, subject)
new_user_data, errors = user_schema.dumps(user)
return dict(status='success',
data=dict(user=json.loads(new_user_data))), 201
def get_user_by_firebase_id():
user_schema = UserSchema()
fb_id = request.args['firebase_id']
user = db.session.query(User).filter(User.firebase_id == fb_id).first()
if user:
return user_schema.dumps(user)
else:
raise NotFound(
"Could not find user with firebase_id of '{}'".format(fb_id))
def test_registered_with_already_registered_user(self):
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='volunteer',
location='nashville')
schema = UserSchema()
self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
response = self.client.post('/users/',
data=schema.dumps(user).data,
content_type='application/json')
data = json.loads(response.data.decode())
self.assertTrue(data['status'] == 'fail')
self.assertTrue(data['message'] == 'User already exists')
self.assertTrue(response.content_type == 'application/json')
self.assertEqual(response.status_code, 202)
def get(self):
"""
"""
user_schema = UserSchema(many=True)
users = User.find_all()
users_data, errors = user_schema.dumps(users)
if errors:
return dict(status='fail', message=errors), 400
return dict(status='success',
data=dict(users=json.loads(users_data))), 200
def get(self):
"""
Getting All users
"""
user_schema = UserSchema(many=True)
users = User.find_all()
users_data, errors = user_schema.dumps(users)
if errors:
return dict(status="fail", message="Internal Server Error"), 500
return dict(status="success",
data=dict(users=json.loads(users_data))), 200
def get(self, user_id):
"""
Get specific user
"""
user_schema = UserSchema()
user = User.get_by_id(user_id)
if not user:
return dict(status='fail', message=f'User with id {user_id} does not exist'), 404
user_data, errors = user_schema.dumps(user)
if errors:
return dict(status='fail', message=errors), 400
return dict(status='success', data=dict(users=json.loads(user_data))), 200
def post(self, user_id):
"""
"""
user_role_schema = UserRoleSchema()
user_role_data = request.get_json()
validated_user_role_data, errors = user_role_schema.load(
user_role_data)
if errors:
return dict(status='fail', message=errors), 400
# Get User
user = User.get_by_id(user_id)
if not user:
return dict(status='fail', message='User not found'), 404
# Get role
role = Role.get_by_id(validated_user_role_data.get('role_id', None))
if not role:
return dict(status='fail', message='Role not found'), 404
if role in user.roles:
return dict(status='fail', message='User already has role'), 409
# adding role to user roles
if role in user.roles:
return dict(status='fail', message='Role already Exists'), 404
user.roles.append(role)
saved_user_role = user.save()
user_schema = UserSchema()
if not saved_user_role:
return dict(status='fail', message='Internal Server Error'), 500
new_user_role_data, errors = user_schema.dumps(user)
return dict(status='success',
data=dict(user_role=json.loads(new_user_role_data))), 201
def post(self, organisation_id):
"""
"""
org_member_schema = OrgMemberSchema()
org_member_data = request.get_json()
validated_org_member_data, errors = org_member_schema.load(
org_member_data)
if errors:
return dict(status='fail', message=errors), 400
# Get User
user = User.get_by_id(validated_org_member_data.get('user_id', None))
if not user:
return dict(status='fail', message='User not found'), 404
# Get organisation
organisation = Organisation.get_by_id(organisation_id)
if not organisation:
return dict(status='fail', message='Organisation not found'), 404
if user in organisation.members:
return dict(status='fail', message='Member already exist'), 409
# adding user to organisation members
organisation.members.append(user)
saved_org_member = organisation.save()
user_schema = UserSchema()
if not saved_org_member:
return dict(status='fail', message='Internal Server Error'), 500
new_org_member_data, errors = user_schema.dumps(user)
return dict(
status='success',
data=dict(
organisation_member=json.loads(new_org_member_data))), 201
def test_user_login_fail(self):
user = User(username='******',
email='*****@*****.**',
password='******',
first_name='charlie',
last_name='fei',
role='volunteer',
location='nashville')
schema = UserSchema()
login_response = self.client.post('/users/login',
data=schema.dumps(user).data,
content_type='application/json')
login_data = json.loads(login_response.data.decode())
self.assertTrue(login_data['status'] == 'fail')
self.assertTrue(login_data['message'] == 'User does not exist.')
self.assertTrue(login_response.content_type == 'application/json')
self.assertEqual(login_response.status_code, 404)
def get(self, user_id):
"""
"""
user_schema = UserSchema()
user = User.get_by_id(user_id)
if not user:
return dict(status='fail',
message=f'user {user_id} not found'), 404
user_data, errors = user_schema.dumps(user)
if errors:
return dict(status='fail', message=errors), 500
return dict(status='success',
data=dict(user=json.loads(user_data))), 200
def get(self, user_id):
"""
Getting individual user
"""
schema = UserSchema()
user = User.get_by_id(user_id)
if not user:
return dict(status="fail",
message=f"User with id {user_id} not found"), 404
user_data, errors = schema.dumps(user)
if errors:
return dict(status="fail", message=errors), 500
return dict(status='success',
data=dict(user=json.loads(user_data))), 200
def delete(self, user_id):
"""
"""
user_role_schema = UserRoleSchema()
user_role_data = request.get_json()
validated_user_role_data, errors = user_role_schema.load(
user_role_data)
if errors:
return dict(status='fail', message=errors), 400
# Get User
user = User.get_by_id(user_id)
if not user:
return dict(status='fail', message='User not found'), 404
# Get role
role = Role.get_by_id(validated_user_role_data.get('role_id', None))
if not role:
return dict(status='fail', message='Role not found'), 404
# removing user from role
try:
user.roles.remove(role)
except Exception:
return dict(status='fail', message='User role not found'), 404
saved_user_role = user.save()
user_schema = UserSchema()
if not saved_user_role:
return dict(status='fail', message='Internal Server Error'), 500
new_user_role_data, errors = user_schema.dumps(user)
return dict(status='success',
data=dict(user_role=json.loads(new_user_role_data))), 201
def post(self):
"""
Creating an User ad
"""
user_schema = UserSchema()
user_data = request.get_json()
validated_user_data, errors = user_schema.load(user_data)
if errors:
return dict(status='fail', message=errors), 400
user = User(**validated_user_data)
saved_user = user.save()
if not saved_user:
return dict(status='fail', message='Internal Server Error'), 500
new_user_data, errors = user_schema.dumps(user)
return dict(status='success',
data=dict(user=json.loads(new_user_data))), 201
def post(self):
user_schema = UserSchema(only=("email", "password"))
login_data = request.get_json()
validated_user_data, errors = user_schema.load(login_data)
if errors:
return dict(status='fail', message=errors), 400
email = validated_user_data.get('email', None)
password = validated_user_data.get('password', None)
user = User.find_first(email=email)
if not user:
return dict(status='fail', message="login failed"), 401
user_data, errors = user_schema.dumps(user)
if errors:
return dict(status='fail', message=errors), 400
return dict(status='Success', message=f"User { user.username } logged in Successfully. "), 200