def test_trip_id(client):
"""should only be present for trip events"""
register_device()
# trip_ip should be present
url = url_for('v0_4_0.vehicle_event', device_id=REGISTERED_DEVICE_ID)
event = {'event_type': 'trip_start'}
kwargs = get_request(generate_payload(event))
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'missing_param': ['trip_id']}))
assert expected.encode() in response.data
# trip_ip should not be present
event = {'event_type': 'register', 'trip_id': str(uuid.uuid4())}
kwargs = get_request(generate_payload(event))
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'bad_param': ['trip_id']}))
assert expected.encode() in response.data
def test_post(client):
url = url_for('v0_4_0.vehicle_register')
response = client.post(url, **get_request(generate_payload()))
assert response.status == '201 CREATED'
assert response.data == b''
# Try with minimal arguments
data = generate_payload()
del data['year']
del data['mfgr']
del data['model']
url = url_for('v0_4_0.vehicle_register')
response = client.post(url, **get_request(data))
assert response.status == '201 CREATED'
assert response.data == b''
def test_unregistred_device(client):
url = url_for('v0_4_0.vehicle_update', device_id=REGISTERED_DEVICE_ID)
kwargs = get_request(generate_payload())
response = client.post(
url,
**kwargs,
)
assert response.status == '404 NOT FOUND'
def test_unregistered_device(client):
url = url_for('v0_4_0.vehicle_event', device_id=REGISTERED_DEVICE_ID)
event = {'event_type': 'register'}
kwargs = get_request(generate_payload(event))
response = client.post(
url,
**kwargs,
)
assert response.status == '404 NOT FOUND'
def test_unregistered_device(client):
url = url_for('v1_0_0.vehicle_event', device_id=REGISTERED_DEVICE_ID)
event = {'vehicle_state': 'available', 'event_types': ['located']}
kwargs = get_request(generate_payload(event))
response = client.post(
url,
**kwargs,
)
assert response.status == '404 NOT FOUND'
def test_valid_post(client):
register_device()
url = url_for('v0_4_0.vehicle_update', device_id=REGISTERED_DEVICE_ID)
response = client.post(
url,
**get_request(generate_payload()),
)
assert response.status == '201 CREATED'
assert response.data == b''
def test_valid_post(client, event_args):
register_device()
url = url_for('v0_4_0.vehicle_event', device_id=REGISTERED_DEVICE_ID)
kwargs = get_request(generate_payload(event_args))
response = client.post(
url,
**kwargs,
)
assert response.status == '201 CREATED'
assert response.data == b''
def test_wrong_type(client):
url = url_for('v1_0_0.vehicle_register')
data = generate_payload()
data['device_id'] = 346
kwargs = get_request(data)
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'bad_param': ['device_id']}))
assert expected.encode() in response.data
def test_valid_post(client):
register_device()
url = url_for('v0_4_0.vehicle_telemetry')
telemetries = [generate_telemetry() for _ in range(2)]
kwargs = get_request(generate_payload(telemetries))
response = client.post(
url,
**kwargs,
)
assert response.status == '201 CREATED'
assert response.data == b'{"result": 2, "failures": []}'
def test_unknown_field(client):
url = url_for('v0_4_0.vehicle_register')
data = generate_payload()
data['unknown_field'] = 'nope'
kwargs = get_request(data)
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'bad_param': ['unknown_field']}))
assert expected.encode() in response.data
def test_wrong_type(client):
register_device()
url = url_for('v0_4_0.vehicle_update', device_id=REGISTERED_DEVICE_ID)
data = {'vehicle_id': 346}
kwargs = get_request(data)
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'bad_param': ['vehicle_id']}))
assert expected.encode() in response.data
def test_event_type_reason(client):
"""required and allowed vaules depends on event_type"""
register_device()
# event_type_reason shouldn't be present
url = url_for('v0_4_0.vehicle_event', device_id=REGISTERED_DEVICE_ID)
event = {'event_type': 'register', 'event_type_reason': 'compliance'}
kwargs = get_request(generate_payload(event))
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'bad_param': ['event_type_reason']}))
assert expected.encode() in response.data
# event_type_reason has a wrong value
event = {'event_type': 'deregister', 'event_type_reason': 'compliance'}
kwargs = get_request(generate_payload(event))
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'bad_param': ['event_type_reason']}))
assert expected.encode() in response.data
# event_type_reason should be present
# TODO confirm if it's true
event = {'event_type': 'deregister'}
kwargs = get_request(generate_payload(event))
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'missing_param':
['event_type_reason']}))
assert expected.encode() in response.data
def test_unknown_field(client):
register_device()
url = url_for('v1_0_0.vehicle_update', device_id=REGISTERED_DEVICE_ID)
data = generate_payload()
data['unknown_field'] = 'nope'
kwargs = get_request(data)
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'bad_param': ['unknown_field']}))
assert expected.encode() in response.data
def test_all_invalid(client):
register_device()
bad_telemetry = generate_telemetry()
del bad_telemetry['device_id']
url = url_for('v0_4_0.vehicle_telemetry')
telemetries = [bad_telemetry, bad_telemetry]
kwargs = get_request(generate_payload(telemetries))
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
def test_already_registred(client):
register_device()
data = generate_payload()
url = url_for('v0_4_0.vehicle_register')
data['device_id'] = REGISTERED_DEVICE_ID
kwargs = get_request(data)
response = client.post(
url,
**kwargs,
)
assert response.status == '409 CONFLICT'
assert b'' in response.data
def test_workflow(client, vehicle_state, event_type):
register_device()
# event_type_reason shouldn't be present
url = url_for('v1_0_0.vehicle_event', device_id=REGISTERED_DEVICE_ID)
event = {'vehicle_state': vehicle_state, 'event_types': [event_type]}
if 'trip' in event_type:
event['trip_id'] = str(uuid.uuid4())
kwargs = get_request(generate_payload(event))
response = client.post(
url,
**kwargs,
)
assert response.status == '201 CREATED'
def test_device_id(client):
register_device()
url = url_for('v0_4_0.vehicle_event', device_id=REGISTERED_DEVICE_ID)
event = {'event_type': 'register'}
data = generate_payload(event)
data['telemetry']['device_id'] = str(uuid.uuid4())
kwargs = get_request(data)
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'bad_param': ['device_id']}))
assert expected.encode() in response.data
def test_query_parameter_resolver_with_raises_argument_not_supported():
@winter.route_get()
def method(invalid_query_param: int):
return invalid_query_param
resolver = QueryParameterArgumentResolver()
request = get_request('invalid_query_param=1')
argument = method.get_argument('invalid_query_param')
with pytest.raises(ArgumentNotSupported) as exception:
resolver.resolve_argument(argument, request, {})
assert str(exception.value
) == 'Unable to resolve argument invalid_query_param: int'
def test_query_parameter_resolver_with_raises_parse_error(
query_string, expected_exception_message):
@winter.route_get('{?query_param}')
def method(query_param: int):
return query_param
resolver = QueryParameterArgumentResolver()
argument = method.get_argument('query_param')
request = get_request(query_string)
with pytest.raises(decoder.JSONDecodeException) as exception:
resolver.resolve_argument(argument, request, {})
assert str(exception.value) == expected_exception_message
def test_query_parameter_resolver(argument_name, query_string, expected_value):
@winter.route_get('{?without_default,optional,with_default,array*}')
def method(
without_default: int,
optional: Optional[str],
array: List[int],
with_default: str = 'default',
):
return without_default, optional, array, with_default
resolver = QueryParameterArgumentResolver()
argument = method.get_argument(argument_name)
request = get_request(query_string)
assert resolver.resolve_argument(argument, request, {}) == expected_value
def test_wrong_type(client):
register_device()
url = url_for('v1_0_0.vehicle_event', device_id=REGISTERED_DEVICE_ID)
event = {'vehicle_state': 'available', 'event_types': ['located']}
data = generate_payload(event)
data['telemetry'] = 346
kwargs = get_request(data)
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'bad_param': ['telemetry']}))
assert expected.encode() in response.data
def test_missing_required(client):
register_device()
url = url_for('v0_4_0.vehicle_event', device_id=REGISTERED_DEVICE_ID)
event = {'event_type': 'register'}
data = generate_payload(event)
del data['timestamp']
kwargs = get_request(data)
response = client.post(
url,
**kwargs,
)
assert response.status == '400 BAD REQUEST'
expected = html.escape(json.dumps({'missing_param': ['timestamp']}))
assert expected.encode() in response.data
def test_orphan_map_query_parameter_fails():
@winter.route_get('{?x,y}')
@winter.map_query_parameter('x', to='x_param')
@winter.map_query_parameter('y', to='y_param')
def method(x_param: int, y_param: int = 1):
return 0
resolver = QueryParameterArgumentResolver()
argument = method.get_argument('x_param')
request = get_request('?x=1')
with pytest.raises(decoder.JSONDecodeException) as exception:
resolver.resolve_argument(argument, request, {})
assert str(exception.value) == 'Missing required query parameter "x"'
def test_unregistered_device(client):
register_device()
url = url_for('v0_4_0.vehicle_telemetry')
good_telemetry = generate_telemetry()
bad_telemetry = generate_telemetry()
bad_telemetry['device_id'] = str(uuid.uuid4())
telemetries = [good_telemetry, bad_telemetry]
kwargs = get_request(generate_payload(telemetries))
response = client.post(
url,
**kwargs,
)
assert response.status == '201 CREATED'
response_data = json.loads(response.data)
assert response_data['result'] == 1
assert response_data['failures'] == [bad_telemetry]
def test_partially_invalid(client):
"""One telemetry is ok, the other is invalid"""
register_device()
good_telemetry = generate_telemetry()
bad_telemetry = generate_telemetry()
del bad_telemetry['device_id']
url = url_for('v0_4_0.vehicle_telemetry')
telemetries = [good_telemetry, bad_telemetry]
kwargs = get_request(generate_payload(telemetries))
response = client.post(
url,
**kwargs,
)
assert response.status == '201 CREATED'
response_data = json.loads(response.data)
assert response_data['result'] == 1
assert response_data['failures'] == [bad_telemetry]
