def fake_request_creation(has_start_time):
user, password = _generate_user()
user.save()
d = {
'customer': user,
'duration': fake.time_delta(),
'latitude': fake.latitude(),
'longitude': fake.longitude(),
'description': fake.text(),
'title': fake.text(),
}
if has_start_time:
d['start_time'] = fake.date_time()
return d
def _generate_user():
kwargs = {}
if choice([True, False]):
kwargs['bio'] = fake.text()
password = fake.password()
return User.objects.create_user(fake.email(), password, fake.first_name(),
fake.last_name(), **kwargs), password
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_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_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_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_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'])
import json
import pytest
from halp_backend.models import User
from halp_backend.tests import fake
from halp_backend.tests.conftest import encode_auth
pytestmark = pytest.mark.django_db
@pytest.mark.parametrize('bio', [
fake.text(),
fake.text(),
fake.text(),
fake.text(),
fake.text(),
])
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 fake_response(request, user=None):
if not user:
user, _ = _generate_user()
response = Response(worker=user, comment=fake.text(), request=request)
response.save()
return response
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)
@pytest.mark.parametrize('data', [
{
'duration': -1,
'latitude': 0,
'longitude': 0,
'description': fake.text(),
'start_time': None
},
{
'duration': 0,
'latitude': 0,
'longitude': 0,
'description': None,
'start_time': None
},
{
'duration': 0,
'latitude': 0,
'longitude': 0,
'description': fake.text(),
'start_time': 1.2
