def test_lookup(self):
''' Test 5: /lookup endpoint'''
# No friend/user name provided
res = go(self.app.get,'/lookup', query_string={'user_email': '', 'friend_email': ''})
self.assertEqual(res().status_code , 400)
# No such user
res = go(self.app.get,'/lookup', query_string={'user_email': self.user, 'friend_email': 'n/a'})
self.server.reply(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(res().status_code , 400)
# Requested user not in friend list
res = go(self.app.get,'/lookup', query_string={'user_email': self.email, 'friend_email': 'not_a_friend'})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['a_friend']}]})
self.assertEqual(res().status_code , 400)
# Look up friend who is not sharing location
res = go(self.app.get,'/lookup', query_string={'user_email': self.email, 'friend_email': 'dont_look_at_me_rn'})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['dont_look_at_me_rn']}]})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': 'dont_look_at_me_rn', 'location_sharing': False}]})
self.assertEqual(res().status_code , 401)
# Look up friend's location successfully
res = go(self.app.get, '/lookup', query_string={'user_email': self.email, 'friend_email': 'look_at_me'})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['look_at_me']}]})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': 'look_at_me', 'location_sharing': True, 'location': {'x': 4, 'y': 4}, 'indoor_location': {'building': 'MooreHall', 'floor': '1', 'x': 16, 'y': 82, 'room': 1009}, 'last_seen_indoor': 0.0}]})
outdoor = {'x': 4, 'y': 4}
indoor = {'building': 'MooreHall', 'floor': '1', 'x': 16, 'y': 82, 'room': 1009}
response = res()
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json()['location']['outdoor_location'], outdoor)
self.assertEqual(response.get_json()['location']['indoor_location'], indoor)
self.assertTrue(response.get_json()['minutes_ago_indoor'])
def test_uninstrumented_clients_no_longer_traces(self):
tracer = MockTracer()
opentracing.tracer = tracer
config.tracer = tracer
instrument(tracer)
client = pymongo.MongoClient(self.server.uri)
fut = go(client.db.collection.insert_many,
[dict(one=123), dict(two=234)])
self.server.receives().ok()
fut()
spans = tracer.finished_spans()
assert len(spans) == 1
assert spans[0].operation_name == 'insert'
uninstrument()
tracer.reset()
client = pymongo.MongoClient(self.server.uri)
fut = go(client.db.collection.insert_many,
[dict(one=123), dict(two=234)])
self.server.receives().ok()
fut()
assert not tracer.finished_spans()
def test_getBuildingMetadata(self):
'''Test 8: /getBuildingMetadata endpoint'''
# No building name provided
res = go(self.app.get, '/getBuildingMetadata', query_string={'building_name': ''})
self.assertEqual(res().status_code, 400)
# Building not in database
res = go(self.app.get, '/getBuildingMetadata', query_string={'building_name': self.building})
self.server.reply(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(res().status_code, 401)
# Get number of floor plans in db for building
res = go(self.app.get, '/getBuildingMetadata', query_string={'building_name': self.building})
self.server.reply(cursor={'id': 0,
'firstBatch': [{'building_name': self.building,
'location': {'longitude': 0.0, 'latitude': 0.0}}]})
self.server.reply(cursor={'id': 0,
'firstBatch': [{'building_name': self.building,
'location': {'longitude': 0.0, 'latitude': 0.0},
'floor': '1',
'vertices': [(0,0), (100,0), (0,100), (100,100)]}]
}
)
self.assertEqual(res().status_code, 200)
self.assertEqual(res().get_json()['number_of_floors'], 1)
self.assertEqual(res().get_json()['location'], {'longitude': 0.0, 'latitude': 0.0})
def test_invalid_shop_id(self):
future = go(self.app.get, '/shops/invalidid', headers=self.auth_header)
self.assertEqual(future().status_code, 400)
future = go(self.app.put, '/shops/invalidid', headers=self.auth_header)
self.assertEqual(future().status_code, 400)
future = go(self.app.delete, '/shops/invalidid', headers=self.auth_header)
self.assertEqual(future().status_code, 400)
def test(self):
self.setup_server(upgrade)
start = time.time()
servers_used = set()
while len(servers_used) < 2:
go(upgrade.function, self.client)
request = self.q.get(timeout=1)
servers_used.add(request.server)
request.assert_matches(upgrade.old if request.server is self.
mongos_old else upgrade.new)
if time.time() > start + 10:
self.fail('never used both mongoses')
def test_get_shop_shops(self):
future = go(self.app.get, '/shops', headers=self.auth_header)
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': []})
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': []})
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(future().status_code, 200)
future = go(self.app.get, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=self.auth_header)
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': [SHOP_RESULT]})
self.assertEqual(future().status_code,200)
def test_notoken(self):
future = go(self.app.get, '/shops/5b3a7297d2e5ce5bbd3d0121')
self.assertEqual(future().status_code, 401)
future = go(self.app.put, '/shops/5b3a7297d2e5ce5bbd3d0121')
self.assertEqual(future().status_code, 401)
future = go(self.app.delete, '/shops/5b3a7297d2e5ce5bbd3d0121')
self.assertEqual(future().status_code, 401)
future = go(self.app.get, '/shops')
self.assertEqual(future().status_code, 401)
future = go(self.app.post, '/shops')
self.assertEqual(future().status_code, 401)
def test_registerLocation(self):
''' Test 4: /registerLocation endpoint'''
# Location update successful
res = go(self.app.post, '/registerLocation', data=json.dumps({'user_email': self.email, 'location': {'latitude': '0.000','longitude': '0.000'}}))
self.server.reply({'n': 1, 'nModified': 1, 'ok': 1.0, 'updatedExisting': True})
self.assertEqual(res().status_code, 200)
# Missing user email
res = go(self.app.post, '/registerLocation', data=json.dumps({'user_email': '', 'location': {'latitude': '0.000','longitude': '0.000'}}))
self.assertEqual(res().status_code, 400)
# Missing location
res = go(self.app.post, '/registerLocation', data=json.dumps({'user_email': self.email}))
self.assertEqual(res().status_code, 400)
def test_shop_notfound(self):
future = go(self.app.get, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=self.auth_header)
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(future().status_code, 400)
future = go(self.app.put, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=self.auth_header, json=SHOP_REQ)
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(future().status_code, 400)
future = go(self.app.delete, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=self.auth_header)
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(future().status_code, 400)
def test_delete_nonexisting_user(self):
USER_REQ = OpMsg({
"find": "users",
"filter": {"login": "******"},
"limit": 1,
"singleBatch": True,
"$db": "authservice",
"$readPreference": {"mode": "primaryPreferred"}},
namespace="authservice")
user = {
"_id": "5b37fff8bbf300b7ef185042",
"login": "******",
"password": "******",
"role": "admin"
}
access_token = generate_access_token(
user=user,
pivate_key=app.config['PRIVATE_KEY'],
auth_host=app.config['AUTH_HOST'],
token_ttl=app.config['TOKEN_TTL'],
auth_algo=app.config['AUTH_ALGO']
)
headers = {'Authorization': 'Bearer {}'.format(access_token['access_token'])}
future = go(self.app.delete, '/auth/signup', headers=headers, json={
"userID": '',
"login": "******",
"password": "******",
"client_id": "midleware1",
"client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"
})
request = self.server.receives(USER_REQ)
request.ok(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(future().status_code, 400)
def test_signup_with_invalid_email(self):
USER_REQ = OpMsg({
"find": "users",
"filter": {"login": "******"},
"limit": 1,
"singleBatch": True,
"$db": "authservice",
"$readPreference": {"mode": "primaryPreferred"}},
namespace="authservice")
CLIENT_REQ = OpMsg({
"find": "clients",
"filter": {"client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"},
"limit": 1,
"singleBatch": True,
"$db": "authservice",
"$readPreference": {"mode": "primaryPreferred"}},
namespace="authservice"
)
future = go(self.app.post, '/auth/signup', json={
"userID": '',
"login": "******",
"password": "******",
"client_id": "midleware1",
"client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"
})
self.assertEqual(future().status_code, 400)
def test_signup_create_existing_user(self):
USER_REQ = OpMsg({
"find": "users",
"filter": {"login": "******"},
"limit": 1,
"singleBatch": True,
"$db": "authservice",
"$readPreference": {"mode": "primaryPreferred"}},
namespace="authservice")
CLIENT_REQ = OpMsg({
"find": "clients",
"filter": {"client_id": "midleware1", "client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"},
"limit": 1,
"singleBatch": True,
"$db": "authservice",
"$readPreference": {"mode": "primaryPreferred"}},
namespace="authservice"
)
future = go(self.app.post, '/auth/signup', json={
"userID": '',
"login": "******",
"password": "******",
"client_id": "midleware1",
"client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"
})
request = self.server.receives(CLIENT_REQ)
request.ok(cursor={'id': 0, 'firstBatch': [CLIENT]})
request = self.server.receives(USER_REQ)
request.ok(cursor={'id': 0, 'firstBatch': [USER]})
def test_put_shop_valid(self):
future = go(self.app.put, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=self.auth_header, json=SHOP_REQ)
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': [SHOP_RESULT]})
request = self.server.receives()
request.ok({'n': 1, 'nModified': 1, 'ok': 1.0, 'updatedExisting': True})
self.assertEqual(future().status_code, 201)
def test_getDataSource(self):
# arrange
future = go(self.app.get, f'/Login-Page/{username}')
request = self.server.receives(
Command(
{
'find': 'dataSources',
'filter': {
'username': username
},
'limit': 1,
'singleBatch': True
},
flags=4,
namespace='app'))
request.ok(
cursor={
'firstBatch':
[{
"username": "******",
"password": "******"["http://http://0.0.0.0:5000/"]
}]
})
# act
http_response = future()
def test_auto_dequeue(self):
server = MockupDB(auto_ismaster=True)
server.run()
client = MongoClient(server.uri)
future = go(client.admin.command, 'ping')
server.autoresponds('ping') # Should dequeue the request.
future()
def test_update(self):
"""Ensure the /repository/update route behaves correctly."""
# arrange
data = {}
keywords = []
keyword = {}
keyword['keyword'] = "noun"
keyword['keyword_type'] = "n"
keywords.append(keyword)
sentencesObj = []
sentenceObj = {}
sentenceObj['badges'] = 'vip/1'
sentenceObj['display_name'] = '黑川大輝'
sentenceObj['username'] = '******'
sentenceObj['user_id'] = '95272'
sentenceObj['room_id'] = '1234'
sentenceObj['tmi_sent_ts'] = '1234567899'
sentenceObj['message'] = 'noun'
sentenceObj['keywords'] = keywords
sentencesObj.append(sentenceObj)
data['sentencesObj'] = sentencesObj
future = go(self.client.post,
'/repository/update',
headers=dict(Authorization='Bearer valid',
LoginType='sso'),
data=json.dumps(data),
content_type='application/json'
)
request = self.server.receives()
request.ok()
request = self.server.receives()
request.ok()
request = self.server.receives()
request.ok(cursor={'id': '5c555871b73882000e44a89a',
'firstBatch': [{
'_id': '5c555871b73882000e44a89a'}]})
request = self.server.receives()
request.ok()
request = self.server.receives()
request.ok()
request = self.server.receives()
request.ok(cursor={'id': '5c555871b73882000e44a89a',
'firstBatch': [{
'_id': '5c555871b73882000e44a89a'}]})
request = self.server.receives()
request.ok()
request = self.server.receives()
request.ok()
# act
http_response = future()
# assert
data = json.loads(http_response.data.decode())
self.assertEqual(http_response.status_code, 200)
self.assertEqual("Repository update", data['message'])
self.assertIn('success', data['status'])
def test_getFriends(self):
'''Test 7: /getFriends endpoint'''
# No username provided
res = go(self.app.get, '/getFriends', query_string={'user_email': ''})
self.assertEqual(res().status_code, 400)
# User doesn't exist
res = go(self.app.get, '/getFriends', query_string={'user_email': 'i_dont_exist'})
self.server.reply(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(res().status_code, 400)
# User exists and has friends
res = go(self.app.get, '/getFriends', query_string={'user_email': self.email})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list':['friend_1']}]})
self.assertEqual(res().status_code, 200)
def test_getDataSource(self):
# arrange
id = '5a8f1e368f7936badfbb0cfa'
future = go(self.app.get, f'/dataSource/{id}')
request = self.server.receives(
Command(
{
'find': 'dataSources',
'filter': {
'_id': mockup_oid(id)
},
'limit': 1,
'singleBatch': True
},
flags=4,
namespace='app'))
request.ok(
cursor={
'id':
0,
'firstBatch': [{
'name': 'bla',
'url': 'http://google.com/rest/api'
}]
})
# act
http_response = future()
# assert
self.assertIn('http://google.com/rest/api',
http_response.get_data(as_text=True))
def test_addDataSource(self):
# arrange
id = '5a924d7a29a6e5484dcf68be'
headers = [('Content-Type', 'application/json')]
# need to pass _id because pymongo creates one so it's impossible to match insert request without _ids
toInsert = {'name': 'new', 'url': 'http://google.com', '_id': id}
future = go(self.app.put,
'/dataSource',
data=dumps(toInsert),
headers=headers)
request = self.server.receives(
Command(
{
'insert':
'dataSources',
'ordered':
True,
'documents': [{
'name': 'new',
'url': 'http://google.com',
'_id': mockup_oid(id)
}]
},
namespace='app'))
request.ok(cursor={'inserted_id': id})
# act
http_response = future()
# assert
data = http_response.get_data(as_text=True)
self.assertIn(id, data)
self.assertEqual(http_response.status_code, 201)
def test_getName(self):
'''Test 10: /getName endpoint'''
# No email provided
res = go(self.app.get, '/getName', query_string={'email': ''})
self.assertEqual(res().status_code, 400)
# No user
res = go(self.app.get, '/getName', query_string={'email': '*****@*****.**'})
self.server.reply(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(res().status_code, 400)
# User exists
res = go(self.app.get, '/getName', query_string={'email': self.email})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'user': self.user, 'email': self.email}]})
self.assertEqual(res().status_code, 200)
def test_deleteDataSource_notFound(self):
# arrange
id = '5a8f1e368f7936badfbb0000'
future = go(self.app.delete, f'/dataSource/{id}')
request = self.server.receives(
Command(
{
'delete': 'dataSources',
'ordered': True,
'deletes': [{
'q': {
'_id': mockup_oid(id)
},
'limit': 1
}]
},
namespace='app'))
request.ok({'acknowledged': True, 'n': 0})
# act
http_response = future()
# assert
self.assertIn(f'{id} not found', http_response.get_data(as_text=True))
self.assertEqual(http_response.status_code, 404)
def test_findSentencesByDisplayname_no_message(self):
"""Ensure error is thrown if no message exist."""
# arrange
display_name = "testUser"
future = go(self.client.get,
f'/repository/findSentencesByDisplayname/{display_name}',
headers=dict(Authorization='Bearer valid', LoginType='sso')
)
request = self.server.receives()
request.ok(cursor={'id': 248441332,
'firstBatch': [{
'id': 248441332,
'badges': None,
'display_name': display_name,
'username': display_name,
'room_id': [],
'tmi_sent_ts': [],
'message_ids': []}]})
# act
http_response = future()
# assert
data = json.loads(http_response.data.decode())
self.assertEqual(http_response.status_code, 404)
self.assertEqual('There is no message.', data['message'])
self.assertIn('Fail', data['status'])
def test_auto_dequeue(self):
server = MockupDB(auto_ismaster=True)
server.run()
client = MongoClient(server.uri)
future = go(client.admin.command, 'ping')
server.autoresponds('ping') # Should dequeue the request.
future()
def test_findDisplaynamesByKeyword_no_user(self):
"""Ensure error is thrown if no user exist."""
# arrange
keyword = "noun"
future = go(self.client.get,
f'/repository/findDisplaynamesByKeyword/{keyword}',
headers=dict(Authorization='Bearer valid', LoginType='sso')
)
request = self.server.receives()
request.ok(cursor={'id': '5c555871b73882000e44a89a',
'firstBatch': [{
'id': '5c555871b73882000e44a89a',
'keyword': keyword,
'keyword_type': 'n',
'user_ids': [],
'message_ids': ['5c5556beb73882000e44a6a3']}]})
# act
http_response = future()
# assert
data = json.loads(http_response.data.decode())
self.assertEqual(http_response.status_code, 404)
self.assertEqual('There is no user.', data['message'])
self.assertIn('Fail', data['status'])
def test_getDataSource(self):
# arrange
id = 1
future = go(self.app.get, f'/add_icecream_id/{id}')
request = self.server.receives(
Command(
{
'find': 'dataSources',
'filter': {
'_id': id
},
'limit': 1,
'singleBatch': True
},
flags=4,
namespace='app'))
request.ok(
cursor={
'id':
0,
'firstBatch': [{
"icecream_name": "Rassberry",
"icecream_flavour": "Rassberry",
"Icecream_type": "Bar",
"Icecream_price": "30/-",
"description": "Nice"
}]
})
# act
http_response = future()
# assert
self.assertIn('http://google.com/rest/api',
http_response.get_data(as_text=True))
def test_signin_get_users(self):
USER_REQ = OpMsg({
"find": "users",
"filter": {},
"projection": {"password": 0},
"$db": "authservice",
"$readPreference": {"mode": "primaryPreferred"}},
namespace="authservice")
user = {
"_id": "5b37fff8bbf300b7ef185042",
"login": "******",
"password": "******",
"role": "admin"
}
access_token = generate_access_token(
user=user,
pivate_key=app.config['PRIVATE_KEY'],
auth_host=app.config['AUTH_HOST'],
token_ttl=app.config['TOKEN_TTL'],
auth_algo=app.config['AUTH_ALGO']
)
headers = {'Authorization': 'Bearer {}'.format(access_token['access_token'])}
future = go(self.app.get, '/auth/signin', headers=headers)
request = self.server.receives(USER_REQ, timeout=60)
request.ok(cursor={'id': 0, 'firstBatch': [USER]})
def test_getDataSources(self):
# arrange
future = go(self.app.get, '/dataSources')
request = self.server.receives(
Command({
'find': 'dataSources',
'filter': {}
},
flags=4,
namespace='app'))
request.ok(
cursor={
'id':
0,
'firstBatch': [{
'name': 'Google',
'url': 'http://google.com/rest/api'
}, {
'name': 'Rest',
'url': 'http://rest.com/rest/api'
}]
})
# act
http_response = future()
# assert
data = http_response.get_data(as_text=True)
self.assertIn('http://google.com/rest/api', data)
self.assertIn('http://rest.com/rest/api', data)
def test_invalid_token(self):
headers = {'Authorization': 'Bearer invalid_token'}
future = go(self.app.get, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=headers)
self.assertEqual(future().status_code, 400)
future = go(self.app.put, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=headers)
self.assertEqual(future().status_code, 400)
future = go(self.app.delete, '/shops/5b3a7297d2e5ce5bbd3d0121', headers=headers)
self.assertEqual(future().status_code, 400)
future = go(self.app.get, '/shops', headers=headers)
self.assertEqual(future().status_code, 400)
future = go(self.app.post, '/shops', headers=headers)
self.assertEqual(future().status_code, 400)
def test_get_liked_disliked_shops(self):
future = go(self.app.get,
'/shops/liked',
headers=self.auth_header,
json=SHOP_REQ)
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': [SHOP_RESULT]})
self.assertEqual(future().status_code, 200)
future = go(self.app.get,
'/shops/disliked',
headers=self.auth_header,
json=SHOP_REQ)
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': [DISLIKER]})
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': [SHOP_RESULT]})
self.assertEqual(future().status_code, 200)
def test_deleteFriend(self):
''' Test 3: /deleteFriend endpoint'''
# Bad arguments
res = go(self.app.get, '/deleteFriend', query_string={'user_email': '', 'friend_email': ''})
self.assertEqual(res().status_code, 400)
# Friend was deleted successfully
res = go(self.app.get, '/deleteFriend', query_string={'user_email': self.email, 'friend_email': '*****@*****.**'})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['*****@*****.**']}]})
self.server.reply({'n': 1, 'ok': 1.0})
self.assertEqual(res().status_code, 200)
# Friend does not exist
res = go(self.app.get, '/deleteFriend', query_string=({'user_email': self.email, 'friend_email': 'i_dont_exist'}))
self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'friends_list': ['i_do_exist']}]})
self.assertEqual(res().status_code, 400)
def test_get_url_not_found(self):
future = go(self.app.get, "/urls/fggg874fbde55")
self.mock_db_get(url="fggg874fbde55")
http_response = future()
self.assertEqual(
"No long url found for this short url fggg874fbde55\n",
http_response.get_data())
