def test_fail(request_factory, create_full_user):
user, password = create_full_user
email = user.email
wrapped = require_auth(mock_view)
request = request_factory.get('/')
request.META['TTP_AUTHORIZATION'] = encode_auth(email, password)
assert wrapped(request).status_code == 401
def test_fail(data, create_full_user, client):
user, password = create_full_user
resp = client.post('/api/v1/request',
data=data,
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 400
def test_fail_bad_body(create_full_user, client):
user, password = create_full_user
data = {'request_i': 1, 'comment': fake.text()}
resp = client.post('/api/v1/create_response',
data=data,
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 400
def test_delete_other_people(create_full_user, client, has_start_time):
user, password = create_full_user
fake_request = fake_request_creation(has_start_time)
request = Request.objects.create_request(**fake_request)
request_id = request.id
resp = client.delete(f'/api/v1/request?request_id={request_id}',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 403
assert Request.objects.filter(id=request_id).exists()
def test_fail_job_not_found(create_full_user, has_start_time, client):
user, password = create_full_user
request = fake_request(has_start_time)
resp = client.post('/api/v1/assign_worker',
data={'request_id': request.id + 1},
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 404
assert request.assigned_to is None
def test_fail_no_request(create_full_user, client, has_start_time):
user, password = create_full_user
req_dict = fake_request_creation(has_start_time)
req = Request.objects.create_request(**req_dict)
data = {'request_id': req.id + 1, 'comment': fake.text()}
resp = client.post('/api/v1/create_response',
data=data,
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 404
def test_delete_success(create_full_user, client, has_start_time):
user, password = create_full_user
fake_request = fake_request_creation(has_start_time)
fake_request['customer'] = user
request = Request.objects.create_request(**fake_request)
request_id = request.id
resp = client.delete(f'/api/v1/request?request_id={request_id}',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
assert not Request.objects.filter(id=request_id).exists()
def test_missing_query_radius(missing, client, create_full_user):
user, password = create_full_user
d = {'lat': 0, 'long': 0, 'radius': 10}
for miss in missing:
del d[miss]
query_string = urlencode(d)
resp = client.get(f'/api/v1/request?{query_string}',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 400
assert 'dependency' in resp.content.decode()
def test_update_bio(bio, create_full_user, client):
user, password = create_full_user
resp = client.post('/api/v1/update_bio',
data={'bio': bio},
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
assert json.loads(resp.content.decode()) == {'bio': bio}
user = User.objects.get(id=user.id)
assert user.bio == bio
def test_success_query(create_full_user, client):
my_user, password = create_full_user
other_users = list(generate_users(10))
for user, _ in other_users:
user.save()
for other, _ in other_users:
resp = client.get(f'/api/v1/profile?user_id={other.id}',
HTTP_AUTHORIZATION=encode_auth(
my_user.email, password))
assert resp.status_code == 200
assert resp.content.decode() == json.dumps(
user_converter.to_dict(other))
def test_fail_finished(create_full_user, client, has_start_time):
user, password = create_full_user
request = fake_request(has_start_time)
request.finished = True
request.save()
resp = client.post('/api/v1/assign_worker',
data={'request_id': request.id},
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 400
assert request.assigned_to is None
def test_assign_success_self(create_full_user, client, has_start_time):
user, password = create_full_user
request = fake_request(has_start_time)
resp = client.post('/api/v1/assign_worker',
data={'request_id': request.id},
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
request = Request.objects.get(id=request.id)
assert request.assigned_to == user
assert json.loads(resp.content) == request_converter.to_dict(request)
def test_fail_not_exist(create_full_user, client):
Request.objects.paired_requests = {}
Request.objects.pending_requests.clear()
user, password = create_full_user
request_dict = fake_request_creation(False)
request = Request.objects.create_request(**request_dict)
resp = client.get(
f'/api/v1/find_worker?request_id={request.id + 1}',
HTTP_AUTHORIZATION=encode_auth(user.email, password)
)
assert resp.status_code == 404
def test_bad_id(create_full_user, client):
Request.objects.paired_requests = {}
Request.objects.pending_requests.clear()
user, password = create_full_user
worker, _ = random.choice(list(generate_users(3)))
request_dict = fake_request_creation(False)
request_dict['customer'] = user
request = Request.objects.create_request(**request_dict)
assert Request.objects.find_job(worker)
resp = client.get(
f'/api/v1/find_worker?request_id={request.id}.1',
HTTP_AUTHORIZATION=encode_auth(user.email, password)
)
assert resp.status_code == 400
def test_fail_cannot_assign_self(create_full_user, client, has_start_time,
has_id):
user, password = create_full_user
request = fake_request(has_start_time, user)
data = {'request_id': request.id}
if has_id:
data['worker_id'] = user.id
resp = client.post('/api/v1/assign_worker',
data=data,
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 400
assert request.assigned_to is None
def test_not_found(create_full_user, client):
Request.objects.paired_requests = {}
Request.objects.pending_requests.clear()
user, password = create_full_user
request_dict = fake_request_creation(False)
request_dict['customer'] = user
request = Request.objects.create_request(**request_dict)
resp = client.get(
f'/api/v1/find_worker?request_id={request.id}',
HTTP_AUTHORIZATION=encode_auth(user.email, password)
)
assert resp.status_code == 200
resp_json = json.loads(resp.content)
assert resp_json['worker'] is None
def test_success(create_full_user, client, has_start_time):
user, password = create_full_user
req_dict = fake_request_creation(has_start_time)
req = Request.objects.create_request(**req_dict)
actual_json = request_converter.to_dict(req)
data = {'request_id': req.id, 'comment': fake.text()}
resp = client.post('/api/v1/create_response',
data=data,
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
resp_json = json.loads(resp.content)
actual_json['responses'].append({
'worker': user_converter.to_dict(user),
'comment': data['comment']
})
for response in resp_json['responses']:
del response['response_id']
assert resp_json == actual_json
def test_success(has_start_time, create_full_user, client):
user, password = create_full_user
d = {
'duration': int(fake.time_delta().total_seconds()),
'latitude': float(fake.latitude()),
'longitude': float(fake.longitude()),
'description': fake.text(),
'title': fake.text(),
}
if has_start_time:
d['start_time'] = int(fake.date_time().timestamp())
resp = client.post('/api/v1/request',
data=d,
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
resp_json = json.loads(resp.content)
request_created = Request.objects.get(id=resp_json['request_id'])
assert resp_json == request_converter.to_dict(request_created)
def test_no_query(create_full_user, client):
user, password = create_full_user
reqeusts = [
fake_request(random.choice([True, False]), user) for _ in range(10)
]
other_requests = [
fake_request(random.choice([True, False])) for _ in range(10)
]
for req in reqeusts:
for _ in range(random.randint(0, 5)):
fake_response(req)
resp = client.get('/api/v1/request',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
resp_dict = json.loads(resp.content)
assert sorted(resp_dict['requests'],
key=lambda d: d['request_id']) == sorted(
(request_converter.to_dict(req) for req in reqeusts),
key=lambda d: d['request_id'])
def test_fail_cannot_assign_others_job(client, has_start_time):
users = list(generate_users(3))
user, password = users[0]
other_user, other_pass = users[1]
worker, worker_pass = users[2]
user.save()
other_user.save()
worker.save()
request = fake_request(has_start_time, other_user)
resp = client.post('/api/v1/assign_worker',
data={
'request_id': request.id,
'worker_id': worker.id
},
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 403
assert request.assigned_to is None
def test_assign_success_other(client, has_start_time):
users = list(generate_users(2))
worker, worker_pass = users[0]
user, password = users[1]
worker.save()
user.save()
request = fake_request(has_start_time, user)
resp = client.post('/api/v1/assign_worker',
data={
'request_id': request.id,
'worker_id': worker.id
},
content_type='application/json',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
request = Request.objects.get(id=request.id)
assert request.assigned_to == worker
assert json.loads(resp.content) == request_converter.to_dict(request)
def test_query(query, expected, create_full_user, client):
user, password = create_full_user
customers = [u for u, _ in generate_users(5)]
workers = [u for u, _ in generate_users(5)]
for u in chain(customers, workers):
u.save()
default_args = lambda: {
'duration': fake.time_delta(),
'latitude': fake.latitude(),
'longitude': fake.longitude(),
'description': fake.text(),
'customer': random.choice(customers)
}
reqeusts = [
Request(start_time=datetime.fromtimestamp(1000),
assigned_to=random.choice(workers),
finished=True,
**default_args()),
Request(start_time=datetime.fromtimestamp(30000),
assigned_to=None,
finished=False,
**default_args())
]
for r in reqeusts:
r.clean()
r.save()
resp = client.get(f'/api/v1/request?{query}',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
resp_dict = json.loads(resp.content)
resp_requests = resp_dict['requests']
assert len(resp_requests) == len(expected)
assert sorted([request_converter.to_dict(reqeusts[i]) for i in expected],
key=lambda d: d['request_id']) == sorted(
resp_requests, key=lambda d: d['request_id'])
def test_query_radius(lat, long, radius, expected, client, create_full_user):
request_dict_lst = [
fake_request_creation(True),
fake_request_creation(False),
]
reqeusts = [Request.objects.create_request(**d) for d in request_dict_lst]
reqeusts[0].latitude = 0
reqeusts[0].longitude = 0
reqeusts[0].save()
reqeusts[1].latitude = -50
reqeusts[1].longitude = 50
reqeusts[1].save()
user, password = create_full_user
resp = client.get(f'/api/v1/request?lat={lat}&long={long}&radius={radius}',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
resp_dict = json.loads(resp.content)
resp_requests = resp_dict['requests']
assert len(resp_requests) == len(expected)
assert sorted([request_converter.to_dict(reqeusts[i]) for i in expected],
key=lambda d: d['request_id']) == sorted(
resp_requests, key=lambda d: d['request_id'])
def test_success(request_factory, create_full_user):
user, password = create_full_user
wrapped = require_auth(mock_view)
request = request_factory.get('/')
request.META['HTTP_AUTHORIZATION'] = encode_auth(user.email, password)
assert wrapped(request) == (user, request)
def test_success(request_factory, create_full_user):
user, password = create_full_user
request = request_factory.get('/')
request.META['HTTP_AUTHORIZATION'] = encode_auth(user.email, password)
assert user == authenticate_user(request).unwrap()
def test_bad_encode(request_factory, create_full_user):
user, password = create_full_user
request = request_factory.get('/')
request.META['HTTP_AUTHORIZATION'] = encode_auth(user.email, password)[:-1]
assert authenticate_user(request).is_none
def test_success(create_full_user, client):
user, password = create_full_user
resp = client.get('/api/v1/profile',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 200
assert resp.content.decode() == json.dumps(user_converter.to_dict(user))
def test_fail_not_found(create_full_user, client):
user, password = create_full_user
resp = client.get(f'/api/v1/profile?user_id={user.id + 1}',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 404
assert 'does not exist' in resp.content.decode()
def test_bad_query(query, client, create_full_user):
user, password = create_full_user
resp = client.get(f'/api/v1/request?{query}',
HTTP_AUTHORIZATION=encode_auth(user.email, password))
assert resp.status_code == 400
assert '"error":' in resp.content.decode()
