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()