def test_get_protocol_by_protocol_id(self):
p = Protocol(value='Turn off the lights')
db_session.add(p)
db_session.commit()
raw = self.app.get('/api/protocol/{}'.format(p.protocol_id))
resp = json.loads(raw.get_data())
self.assertEqual(p.to_json(), resp)
def test_get_building_by_name(self):
b = Building(name='Shelby')
db_session.add(b)
db_session.commit()
resp = json.loads(
self.app.get('/api/building/{}'.format(b.name)).get_data())
self.assertEqual(resp, b.to_json())
def add_remove_protocol_family_association(family_id, protocol_id):
family = ProtocolFamily.query.filter(
ProtocolFamily.family_id == family_id).first()
if family is None:
return _error('Protocol family does not exist', 404)
protocol = Protocol.query.filter(
Protocol.protocol_id == protocol_id).first()
if protocol is None:
return _error('Protocol does not exists', 404)
pfp = ProtocolFamilyProtocol.query.filter(
ProtocolFamilyProtocol.family_id == family.family_id,
ProtocolFamilyProtocol.protocol_id == protocol.protocol_id).first()
if request.method == 'POST':
if pfp is not None:
return _error('Protocol already exists in specified family', 400)
pfp = ProtocolFamilyProtocol(family.family_id, protocol.protocol_id)
db_session.add(pfp)
db_session.commit()
return jsonify(pfp.to_json())
# Must be a delete
if pfp is None:
return _error('Protocol does not exist in specified family', 404)
to_delete = pfp.to_json()
db_session.delete(pfp)
db_session.commit()
return jsonify(to_delete)
def connect_part_protocol(element_id, protocol_id):
part = Part.query.filter(Part.element_id == element_id).first()
if part is None:
return _error('Part element_id does not exist', 404)
protocol = Protocol.query.filter(
Protocol.protocol_id == protocol_id).first()
if protocol is None:
return _error('Protocol protocol_id does not exist', 404)
pp = (PartProtocol.query.filter(
PartProtocol.part_id == part.part_id,
PartProtocol.protocol_id == protocol_id).first())
if request.method == 'POST':
if pp is not None:
return _error('Protocol is already associated with that part', 400)
pp = PartProtocol(part_id=part.part_id, protocol_id=protocol_id)
db_session.add(pp)
db_session.commit()
return jsonify(pp.to_json())
# Must be a delete
if pp is None:
return _error('Part protocol relationship does not exist', 404)
to_delete = pp.to_json()
db_session.delete(pp)
db_session.commit()
return jsonify(to_delete)
def user_info():
if request.method == 'GET':
return jsonify(current_user.to_json())
if not request.is_json:
return _error('Request must be JSON type', 400)
form = request.get_json()
hashed = bcrypt.hashpw(form['password'].encode('utf-8'), bcrypt.gensalt())
user = User.query.filter(User.email == form['email']
or User.id == form['_id']).first()
print(user)
if request.method == 'PUT':
if user is not None:
return _error('An account with that email already exists', 400)
new_user = User(first_name=form.get('first_name'),
last_name=form.get('last_name'),
email=form['email'],
password=hashed)
db_session.add(new_user)
db_session.commit()
return jsonify(new_user.to_json())
elif request.method == 'POST':
if user is None:
return _error('Specified user not found', 400)
user.first_name = form.get('first_name')
user.last_name = form.get('last_name')
user.email = form.get('email')
if form.get('password') is not None:
user.password = hashed
db_session.add(user)
db_session.commit()
return jsonify(user.to_json())
return _error('Invalid request type.', 400)
def test_delete_protocol_family_successful(self):
db_session.add(self.family1)
db_session.commit()
q_str = '/api/protocol-family/{}'.format(self.family1.family_id)
self.app.delete(q_str)
fam = ProtocolFamily.query.first()
self.assertIsNone(fam)
def test_add_family_protocol_association_nonexistent_protocol(self):
db_session.add_all([self.family1])
db_session.commit()
q_str = '/api/protocol-family/{}/protocol/{}'.format(
self.family1.family_id, 999)
raw = self.app.post(q_str)
self.assertEqual(404, raw.status_code)
def test_get_protocol_families(self):
db_session.add_all([self.family1, self.family2])
db_session.commit()
resp = json.loads(self.app.get('/api/protocol-family').data)
self.assertEqual(resp,
[self.family1.to_json(),
self.family2.to_json()])
def test_delete_protocol(self):
db_session.add(self.protocol1)
db_session.commit()
pid = self.protocol1.protocol_id
self.app.delete('/api/protocol/{}'.format(pid))
deleted = Protocol.query.filter(Protocol.protocol_id == pid).first()
self.assertTrue(deleted is None)
def test_delete_family_protocol_association_nonexistent_association(self):
db_session.add_all([self.protocol1, self.family1])
db_session.commit()
q_str = '/api/protocol-family/{}/protocol/{}'.format(
self.family1.family_id, self.protocol1.protocol_id)
raw = self.app.delete(q_str)
self.assertEqual(raw.status_code, 404)
def test_delete_building(self):
db_session.add(self.building1)
db_session.commit()
bid = self.building1.building_id
self.app.delete('/api/building/{}'.format(bid))
deleted = Building.query.filter(Building.building_id == bid).first()
self.assertTrue(deleted is None)
def get_building_by_identifier(building_id=None, name=None):
# Validate that the building exists
if building_id is not None:
# Lookup by id
building = (Building.query.filter(
Building.building_id == building_id).first())
else:
# Lookup by name
building = (Building.query.filter(Building.name == name).first())
if building is None:
return _error('The specified building does not exist', 404)
if request.method == 'DELETE':
bid = building.building_id
db_session.delete(building)
db_session.commit()
return jsonify({'building_id': bid})
if request.method == 'PUT':
if not request.is_json:
return _error('Request must be JSON type', 400)
form = request.get_json()
if 'name' not in form:
return _error('Name key not specified', 400)
if not set(form.keys()).issubset({'name'}):
return _error('Extra keys specified', 400)
building.name = form['name']
db_session.commit()
return jsonify(building.to_json())
def part_info(element_id):
part = Part.query.filter(Part.element_id == element_id).first()
if part is None:
return _error('Part not found', 404)
if request.method == 'DELETE':
part_id = part.part_id
db_session.delete(part)
db_session.commit()
return jsonify({'part_id': part_id})
if request.method == 'PUT':
if not request.is_json:
return _error('Request must be JSON type', 400)
form = request.get_json()
if 'building_id' in form and form['building_id'] is not None:
# Validate that the building exists
building = (Building.query.filter(
Building.building_id == form['building_id']).first())
if building is None:
return _error('Specified building does not exist', 404)
if not set(form.keys()).issubset(part.to_json().keys()):
return _error('Unknown properties specified in request', 400)
part.element_id = form.get('element_id')
part.building_id = form.get('building_id')
part.part_name = form.get('part_name')
db_session.add(part)
db_session.commit()
return jsonify(part.to_json())
def test_edit_protocol_family_not_json(self):
db_session.add(self.family1)
db_session.commit()
q_str = '/api/protocol-family/{}'.format(self.family1.family_id)
raw = self.app.put(q_str,
content_type='text/html',
data='this is not json')
self.assertEqual(raw.status_code, 400)
def test_put_building_not_json(self):
db_session.add(self.building1)
db_session.commit()
raw = self.app.put('/api/building/{}'.format(
self.building1.building_id),
content_type='text/html',
data='This is not json')
self.assertEqual(raw.status_code, 400)
def test_edit_protocol_family_no_family_name(self):
db_session.add(self.family1)
db_session.commit()
q_str = '/api/protocol-family/{}'.format(self.family1.family_id)
raw = self.app.put(q_str,
content_type='application/json',
data=json.dumps({}))
self.assertEqual(raw.status_code, 400)
def test_put_protocol_no_value_specified(self):
db_session.add(self.protocol1)
db_session.commit()
raw = self.app.put('/api/protocol/{}'.format(
self.protocol1.protocol_id),
content_type='application/json',
data='{}')
self.assertEqual(raw.status_code, 400)
def test_put_protocol_not_json(self):
db_session.add(self.protocol1)
db_session.commit()
raw = self.app.put('/api/protocol/{}'.format(
self.protocol1.protocol_id),
content_type='text/html',
data='This is not JSON')
self.assertEqual(raw.status_code, 400)
def test_delete_part(self):
db_session.add(self.part1)
db_session.commit()
part_id = self.part1.part_id
raw = self.app.delete('/api/part/{}'.format(self.part1.element_id))
deleted = Part.query.first()
self.assertTrue(deleted is None)
self.assertEquals({'part_id': part_id}, json.loads(raw.data))
def test_put_not_json_fails(self):
db_session.add(self.part1)
db_session.commit()
to_put = self.part1.to_json()
raw = self.app.put('/api/part/{}'.format(self.part1.element_id),
content_type='text/html',
data='This is not json')
self.assertEqual(400, raw.status_code)
def test_put_building_no_name(self):
db_session.add(self.building1)
db_session.commit()
raw = self.app.put('/api/building/{}'.format(
self.building1.building_id),
content_type='application/json',
data='{}')
self.assertEqual(raw.status_code, 400)
def test_connect_part_protocol_nonexistent_protocol_fails(self):
part = Part(element_id=1234)
db_session.add(part)
db_session.commit()
raw = self.app.post('/api/part/{}/protocol/{}'.format(
part.element_id, 100))
resp = json.loads(raw.data)
self.assertEqual(raw.status_code, 404)
self.assertTrue(resp['Error'].startswith('Protocol'))
def test_connect_part_protocol_nonexistent_part_fails(self):
protocol = Protocol(value='Turn off the lights when leaving')
db_session.add(protocol)
db_session.commit()
raw = self.app.post('/api/part/{}/protocol/{}'.format(
100, protocol.protocol_id))
self.assertEqual(raw.status_code, 404)
resp = json.loads(raw.data)
self.assertTrue(resp['Error'].startswith('Part'))
def test_add_family_protocol_association_successful(self):
db_session.add_all([self.family1, self.protocol1])
db_session.commit()
q_str = '/api/protocol-family/{}/protocol/{}'.format(
self.family1.family_id, self.protocol1.protocol_id)
self.app.post(q_str)
pfp = ProtocolFamilyProtocol.query.first()
self.assertEqual(pfp.family_id, self.family1.family_id)
self.assertEqual(pfp.protocol_id, self.protocol1.protocol_id)
def test_connect_part_protocol(self):
part = Part(element_id=1234)
protocol = Protocol(value='Turn off the lights when leaving')
db_session.add_all([part, protocol])
db_session.commit()
raw = self.app.post('/api/part/{}/protocol/{}'.format(
part.element_id, protocol.protocol_id))
resp = json.loads(raw.data)
added = PartProtocol.query.first()
self.assertEqual(resp, added.to_json())
def test_put_part_extra_keys_fails(self):
db_session.add(self.part1)
db_session.commit()
to_put = self.part1.to_json()
to_put['element_id'] = 111
to_put['not_an_attr'] = 'something'
raw = self.app.put('/api/part/{}'.format(self.part1.element_id),
content_type='application/json',
data=json.dumps(to_put))
self.assertEqual(400, raw.status_code)
def test_put_protocol(self):
db_session.add(self.protocol1)
db_session.commit()
raw = self.app.put('/api/protocol/{}'.format(
self.protocol1.protocol_id),
content_type='application/json',
data=json.dumps({'value': 'different'}))
changed = Protocol.query.filter(
Protocol.protocol_id == self.protocol1.protocol_id).first()
self.assertEqual(changed.value, 'different')
def test_edit_protocol_family_successful(self):
fam = ProtocolFamily(family_name='Testfam', family_id=0)
db_session.add(fam)
db_session.commit()
q_str = '/api/protocol-family/0'
self.app.put(q_str,
content_type='application/json',
data=json.dumps({'family_name': 'super family1'}))
changed = ProtocolFamily.query.first()
self.assertEqual(changed.to_json()['family_name'], 'super family1')
def test_put_protocol_extra_keys_specified(self):
db_session.add(self.protocol1)
db_session.commit()
raw = self.app.put('/api/protocol/{}'.format(
self.protocol1.protocol_id),
content_type='application/json',
data=json.dumps({
'value': 'something',
'else': 'no good'
}))
self.assertEqual(raw.status_code, 400)
def test_put_building_extra_keys(self):
db_session.add(self.building1)
db_session.commit()
raw = self.app.put('/api/building/{}'.format(
self.building1.building_id),
content_type='application/json',
data=json.dumps({
'name': 'Better Shelby',
'something': 'else'
}))
self.assertEqual(raw.status_code, 400)
