class TestGet(unittest.TestCase):
@classmethod
def setUp(self):
self.server = MockupDB(auto_ismaster=True, verbose=True)
self.server.run()
app.testing = True
app.config['MONGO_URI'] = self.server.uri
self.client = app.test_client()
@classmethod
def tearDown(self):
self.server.stop()
# os.close(self.db_fd)
# os.unlink(app.config['MONGO_URI'])
@classmethod
def test_getlist(self):
document = DOCUMENT
future = go(self.client.get, '/api/robot')
request = self.server.receives()
request.reply(document)
http_response = future()
data = http_response.get_data(as_text=True)
self.assertIn('not_a_robot', data)
self.assertIn('kawada-hironx', data)
class BaseTestCase(TestCase):
def create_app(self):
app.config.from_object('project.config.TestingConfig')
self.server = MockupDB(auto_ismaster=True)
self.server.run()
app.config['MONGO_URI'] = self.server.uri
mongo.init_app(app)
return app
def setUp(self):
pass
def tearDown(self):
self.server.stop()
class BaseTestCase(unittest.TestCase):
server = None
@classmethod
def setUpClass(self):
self.server = MockupDB(auto_ismaster=True, verbose=True)
self.server.run()
# create mongo connection to mock server
app.app.testing = True
app.app.config['MONGO_URI'] = self.server.uri
self.app = app.app.test_client()
@classmethod
def tearDownClass(self):
self.server.stop()
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)
class Test(TestCase):
def setUp(self):
self.app = app.app.test_client()
self.server = MockupDB(auto_ismaster=True)
self.server.run()
def tearDown(self):
self.server.stop()
def test_index(self):
response = self.app.get('/')
assert response.status_code == 200
def test_search_method_not_allowed(self):
response = self.app.get('/supermercado/assembler')
assert response.status_code == 405
def test_search_is_number(self):
product_id = 181
response = self.app.post('/supermercado/assembler?search='+str(product_id))
response_json = json.loads(response.data)
if app.mongo.db.products.find_one({"id": product_id}):
assert response_json['count'] == 1
assert response_json['products'][0]['id'] == product_id
else:
assert response_json['count'] == 0
def test_search_is_palindrome(self):
response = self.app.post('/supermercado/assembler?search=daad')
response_json = json.loads(response.data)
assert response_json['discount'] == True
def test_search_is_not_palindrome(self):
response = self.app.post('/supermercado/assembler?search=daads')
response_json = json.loads(response.data)
assert response_json['discount'] == False
def test_search_is_palindrome_but_less_4_characters(self):
response = self.app.post('/supermercado/assembler?search=dad')
response_json = json.loads(response.data)
assert response_json['discount'] == False
class FlaskrTestCase(unittest.TestCase):
@classmethod
def setUp(self):
self.server = MockupDB(auto_ismaster=True, verbose=True)
self.server.run()
app.config['TESTING'] = True
app.config['MONGO_URI'] = self.server.uri
self.app = app.test_client()
@classmethod
def tearDownClass(self):
self.server.stop()
def test_outputs(self):
rv = self.app.get('/outputs')
','.join(SUPPORTED) in rv.data.decode("utf-8")
def test_msg_with_output(self):
rv = self.app.get('/?output=json')
self.assertEquals({'imie': 'Natalia', 'mgs': 'Hello World!'}, rv.json)
class PyMongoTestSuite(object):
@pytest.fixture(autouse=True)
def mocked_mongo(self):
try:
self.server = MockupDB(auto_ismaster={"maxWireVersion": 3})
self.server.run()
yield
finally:
self.server.stop()
@pytest.fixture(autouse=True)
def restored_pymongo_config(self):
orig = dict(config.__dict__)
yield
config.__dict__ = orig
@pytest.fixture(autouse=True)
def uninstrument_pymongo(self):
yield
uninstrument()
class MockupDBFlaskTest(unittest.TestCase):
def setUp(self):
self.server = MockupDB(3000, 'mongodb://localhost')
self.server.run()
# print('11111111111',self.server.uri)
self.app = make_app(self.server.uri).test_client()
print('000000000', self.app.get)
def tearDown(self):
self.server.stop()
def test(self):
future = go(self.app.get, "/pages/my_page_name")
print('11111111', future)
request = self.server.receives()
print('22222', request)
request.reply({"contents": "foo"})
http_response = future()
print('333333333', http_response.get_data(as_text=True))
self.assertEqual("foo", http_response.get_data(as_text=True))
def test_unix_domain_socket(self):
tmp = tempfile.NamedTemporaryFile(delete=False, suffix='.sock')
tmp.close()
server = MockupDB(auto_ismaster={'maxWireVersion': 3},
uds_path=tmp.name)
server.run()
self.assertTrue(
server.uri.endswith('.sock'),
'Expected URI "%s" to end with ".sock"' % (server.uri, ))
self.assertEqual(server.host, tmp.name)
self.assertEqual(server.port, 0)
self.assertEqual(server.address, (tmp.name, 0))
self.assertEqual(server.address_string, tmp.name)
client = MongoClient(server.uri)
with going(client.test.command, {'foo': 1}) as future:
server.receives().ok()
response = future()
self.assertEqual(1, response['ok'])
server.stop()
self.assertFalse(os.path.exists(tmp.name))
class TestProductController(unittest.TestCase):
@classmethod
def setUpClass(self) -> None:
self.server = MockupDB(auto_ismaster=True, verbose=True)
self.server.run()
Config.MONGO_URI = self.server.uri
app = create_app()
self.app = app.test_client()
@classmethod
def tearDownClass(self) -> None:
self.server.stop()
def test_create_product(self):
to_insert = {
"title": "First Aid kit",
"description": "Your helper in journey",
"params": {
'price': 350,
'class': 'B'
}
}
headers = [('Content-Type', 'application/json')]
go(self.app.post, '/api/product', data=dumps(to_insert), headers=headers)
rv = self.server.receives()
new_object_id = str(rv.docs[0]['documents'][0]['_id'])
go(self.app.get, f'/api/product/{new_object_id}', headers=headers)
request = self.server.receives()
request_status = request.ok(cursor={'id': new_object_id, 'firstBatch': [
to_insert
]})
self.assertTrue(request_status)
class SignInTest(unittest.TestCase):
def setUp(self):
"""
Prepare the test envirement.
start the server to mockup the database
"""
self.server = MockupDB(auto_ismaster=True, verbose=True)
self.server.run()
app.testing = True
app.config['MONGO_URI'] = self.server.uri
self.app = app.test_client()
def tearDown(self):
"""shuts down the mockupDB server"""
self.server.stop()
def test_signin_invalid_client(self):
USER_REQ = OpMsg({
"find": "users",
"filter": {"login": "******", "password": "******"},
"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/signin', json={
"userID": '',
"login": "******",
"password": "******",
"client_id": "midleware1",
"client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"
})
request = self.server.receives(USER_REQ)
request.ok(cursor={'id': 0, 'firstBatch': [USER]})
request = self.server.receives(CLIENT_REQ)
request.ok(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(future().status_code, 400)
def test_signin_invalid_user(self):
USER_REQ = OpMsg({
"find": "users",
"filter": {"login": "******", "password": "******"},
"limit": 1,
"singleBatch": True,
"$db": "authservice",
"$readPreference": {"mode": "primaryPreferred"}},
namespace="authservice")
future = go(self.app.post, '/auth/signin', 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_signin_valid_user(self):
USER_REQ = OpMsg({
"find": "users",
"filter": {"login": "******", "password": "******"},
"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/signin', json={
"userID": '',
"login": "******",
"password": "******",
"client_id": "midleware1",
"client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"
})
request = self.server.receives(USER_REQ)
request.ok(cursor={'id': 0, 'firstBatch': [USER]})
request = self.server.receives(CLIENT_REQ)
request.ok(cursor={'id': 0, 'firstBatch': [CLIENT]})
self.assertEqual(future().status_code, 200)
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]})
class AppTest(unittest.TestCase):
'''
Unit test for app.py.
Uses mockupdb to act as the database.
Each endpoint is tested in a seperate method.
'''
def setUp(self):
''' Set up test fixtures '''
self.user = '******'
self.email = '*****@*****.**'
self.building = 'test_building'
self.image_path = os.path.join(os.environ.get('FULL_IMAGE_DIR'), 'MooreHall_1.jpg')
self.server = MockupDB(auto_ismaster={"maxWireVersion": 6})
self.server.run()
self.app = app.create_test_app(self.server.uri).test_client()
def tearDown(self):
''' Take down test fixtures '''
self.server.stop()
def test_addUser(self):
'''Test 1: /addUser endpoint'''
# No username or email provided
res = go(self.app.get, '/addUser', query_string={'user_name': '', 'user_email': ''})
self.assertEqual(res().status_code, 400)
# User doesn't exist
res = go(self.app.get, '/addUser', query_string={'user_name': self.user, 'user_email': self.email})
self.server.reply(cursor={'id': 0, 'firstBatch': [None]})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'user': self.user, 'email': self.email}]})
self.assertEqual(res().status_code, 200)
# User was added twice
res = go(self.app.get, '/addUser', query_string={'user_name': self.user, 'user_email': self.email})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'user': self.user, 'email': self.email}]})
self.assertEqual(res().status_code, 400)
# def test_addFriend(self):
# ''' Test 2: /addFriend endpoint'''
# # No username/friend provided
# res = go(self.app.get, '/addFriend', query_string={'user_email': '', 'friend_email': ''})
# self.assertEqual(res().status_code, 400)
# # Friend was added successfully
# res = go(self.app.get, '/addFriend', 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, 'nModified': 1, 'ok': 1.0, 'updatedExisting': True})
# self.assertEqual(res().status_code, 200)
# # Add friend to non-existent user
# res = go(self.app.get, '/addFriend', query_string={'user_email': 'not_a_user', 'friend_email': 'friend_test'})
# self.server.reply(cursor={'id': 0, 'firstBatch': []})
# self.assertEqual(res().status_code, 400)
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_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_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_toggle(self):
'''Test 6: /toggle endpoint'''
# No username provided
res = go(self.app.get, '/toggle', query_string={'user_email': ''})
self.assertEqual(res().status_code, 400)
# User doesn't exist
res = go(self.app.get, '/toggle', query_string={'user_email': 'i_dont_exist'})
self.server.reply(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(res().status_code, 400)
# Untoggle
res = go(self.app.get, '/toggle', query_string={'user_email': self.email})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': 'toggle_me', 'location_sharing': False}]})
self.server.reply({'n': 1, 'ok': 1.0})
self.assertEqual(res().status_code, 200)
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_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_modal_to_pixel(self):
'''Test 9: modal_to_pixel function'''
'''
Using default shape=[100, 100]
Condition evaluation: TTFF
Branch coverage: 50%
'''
res = go(my_app.model_to_pixel, -1, -1)
self.assertEqual(res(), (0, 0))
'''
Using shape=[500, 500]
Condition evaluation: FFTT
Branch coverage: 100%
'''
res = go(my_app.model_to_pixel, 101, 101, [500, 500])
self.assertEqual(res(), (500, 500))
def test_add_floor(self):
pass
def test_get_floor_image(self):
pass
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_add_building(self):
'''Test 11: /addBuilding endpoint'''
# Building already exist
name = 'my_new_building'
longitude = 1.0
latitude = 10.0
res = go(self.app.get, '/addBuilding', query_string={'building_name': name, 'longitude': longitude, 'latitude': latitude})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'building_name': name, 'location': {'longitude': longitude, 'latitude': latitude}}]})
self.assertEqual(res().status_code, 401)
# Added successfully
name = 'my_new_building'
longitude = 1.0
latitude = 10.0
res = go(self.app.get, '/addBuilding', query_string={'building_name': name, 'longitude': longitude, 'latitude': latitude})
self.server.reply(cursor={'id': 0, 'firstBatch': [None]})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'building_name': name, 'location': {'longitude': longitude, 'latitude': latitude}}]})
self.assertEqual(res().status_code, 200)
# Missing arguments
res = go(self.app.get, '/addBuilding', query_string={'building_name': 'a_building'})
self.assertEqual(res().status_code, 400)
def test_registerIndoor(self):
'''Test 12: /registerIndoor endpoint'''
location={'building': 'MooreHall','floor': '1', 'x': 15, 'y': 58}
# Success
res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': self.email, 'location': location}))
self.server.reply({'n': 1, 'ok': 1.0})
self.server.reply({'n': 1, 'ok': 1.0})
self.assertEqual(res().status_code, 200)
# Missing user email
res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': '', 'location': location}))
self.assertEqual(res().status_code, 400)
# Missing location
res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': self.email, 'location': {}}))
self.assertEqual(res().status_code, 400)
# No floor plan found
res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': self.email, 'location': {'building': 'Boelter', 'floor': '1', 'x': 16, 'y': 82}}))
self.assertEqual(res().status_code, 400)
'''
Return: no floor plan found
# Register location successfully
res = go(self.app.post, '/registerIndoor', data=json.dumps({'user_email': self.email, 'location': {'building': 'MooreHall', 'floor': '1', 'x': 16, 'y': 82}}))
print(res().data)
#self.server.reply(cursor={'id': 0, 'firstBatch': [{'email': self.email, 'location_sharing': True, 'indoor_location': {'building': 'MooreHall', 'floor': '1', 'x': 16, 'y': 82, 'room': 1009}}]})
#self.server.reply({'n': 1, 'nModified': 1, 'ok': 1.0, 'updatedExisting': True})
self.assertEqual(res().status_code, 200)
'''
def test_getFloorImage(self):
'''Test 13: /getFloorImage endpoint'''
res = go(self.app.get, '/getFloorImage', query_string={'building_name': self.building, 'floor': 1})
self.assertEqual(res().status_code, 200)
def test_addFloor(self):
'''Test 14: /addFloor endpoint'''
res = go(self.app.post, '/addFloor', data={'building_name': self.building, 'floor_number': 1, 'floor_plan': (io.BytesIO(open(self.image_path, 'rb').read()), 'MooreHall_1.jpg')})
self.server.reply(cursor={'id': 0, 'firstBatch': [{'building_name': self.building, 'location': dict(longitude=10, latitude=10)}]})
self.server.reply(cursor={'id': 0, 'firstBatch': [None]})
self.assertEqual(res().status_code, 200)
# No building_name
res = go(self.app.post, '/addFloor', data={'building_name': '', 'floor_number': 1, 'floor_plan': (io.BytesIO(open(self.image_path, 'rb').read()), 'MooreHall_1.jpg')})
self.assertEqual(res().status_code, 400)
# No floor
res = go(self.app.post, '/addFloor', data={'building_name': self.building, 'floor_plan': (io.BytesIO(open(self.image_path, 'rb').read()), 'MooreHall_1.jpg')})
self.assertEqual(res().status_code, 400)
# No image
res = go(self.app.post, '/addFloor', data={'building_name': self.building, 'floor_number': 1})
self.assertEqual(res().status_code, 400)
class TestLikedDislikedShop(unittest.TestCase):
def setUp(self):
"""
Prepare the test envirement.
start the server to mockup the database
"""
self.server = MockupDB(auto_ismaster=True, verbose=True)
self.server.run()
app.testing = True
app.config['MONGO_URI'] = self.server.uri
self.app = app.test_client()
self.token = mock_access_token()['access_token']
self.auth_header = {'Authorization': 'Bearer {}'.format(self.token)}
def tearDown(self):
self.server.stop()
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_post_like_dislike_shops(self):
future = go(self.app.post,
'/shops/liked',
headers=self.auth_header,
json=SHOP_REQ)
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({
'n': 1,
'nModified': 1,
'ok': 1.0,
'updatedExisting': True
})
self.assertEqual(future().status_code, 201)
def test_delete_like_dislike_shop_valid(self):
future = go(self.app.delete,
'/shops/5b3a7297d2e5ce5bbd3d0121',
headers=self.auth_header)
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': [SHOP_RESULT]})
request = self.server.receives()
request.ok()
request = self.server.receives()
request.ok(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(future().status_code, 204)
class ManagerTestCase(unittest.TestCase):
maxDiff = None # unittest: show full diff on assertion failure
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.server = MockupDB(auto_ismaster={"maxWireVersion": 6})
self.server.run()
self.server.autoresponds(
Command("find", "switch_collection",
namespace="topology_database"),
{
"cursor": {
"id":
0,
"firstBatch": [{
**d, "_id": i
} for i, d in enumerate(TOPOLOGY_DATABASE_DATA)],
}
},
)
self._stack = AsyncExitStack()
td = self._stack.enter_context(tempfile.TemporaryDirectory())
self.rpc_unix_sock = os.path.join(td, "l.sock")
self._stack.enter_context(
patch.object(settings, "REMOTE_DATABASE_MONGO_URI",
self.server.uri))
self._stack.enter_context(
patch.object(settings, "NEGOTIATOR_RPC_UNIX_SOCK_PATH",
self.rpc_unix_sock))
self._stack.enter_context(
patch("agile_mesh_network.ryu.amn_manager.OVSManager",
DummyOVSManager))
self._stack.enter_context(
# To avoid automatic connection to a relay.
patch.object(settings, "IS_RELAY", True))
self._stack.enter_context(
patch.object(events_scheduler, "RyuAppEventLoopScheduler"))
self.ryu_ev_loop_scheduler = events_scheduler.RyuAppEventLoopScheduler(
)
self._stack.enter_context(self.ryu_ev_loop_scheduler)
async def command_cb(session, msg):
assert isinstance(msg, RPCCommand)
await self._rpc_command_cb(msg)
self.rpc_server = self.loop.run_until_complete(
self._stack.enter_async_context(
RPCUnixServer(self.rpc_unix_sock, command_cb)))
async def _rpc_command_cb(self, msg: RPCCommand):
self.assertEqual(msg.name, "dump_tunnels_state")
await msg.respond({"tunnels": []})
def tearDown(self):
self.loop.run_until_complete(self._stack.aclose())
self.loop.run_until_complete(self.loop.shutdown_asyncgens())
self.loop.close()
self.server.stop()
def test_topology_database_sync(self):
async def f():
async with AgileMeshNetworkManager(
ryu_ev_loop_scheduler=self.ryu_ev_loop_scheduler
) as manager:
manager.start_initialization()
topology_database = manager.topology_database
local_database = topology_database.local
await local_database.is_filled_event.wait()
self.assertTrue(local_database.is_filled)
self.assertListEqual(
topology_database.find_random_relay_switches(),
[SwitchEntity.from_dict(SWITCH_ENTITY_RELAY_DATA)],
)
with self.assertRaises(KeyError):
topology_database.find_switch_by_mac(UNK_MAC)
self.assertEqual(
topology_database.find_switch_by_mac(
SWITCH_ENTITY_BOARD_DATA["mac"]),
SwitchEntity.from_dict(SWITCH_ENTITY_BOARD_DATA),
)
self.assertListEqual(
topology_database.find_switches_by_mac_list([]), [])
self.assertListEqual(
topology_database.find_switches_by_mac_list([UNK_MAC]), [])
self.assertListEqual(
topology_database.find_switches_by_mac_list(
[UNK_MAC, SWITCH_ENTITY_BOARD_DATA["mac"]]),
[SwitchEntity.from_dict(SWITCH_ENTITY_BOARD_DATA)],
)
# TODO after resync extra tunnels/flows are destroyed
self.loop.run_until_complete(asyncio.wait_for(f(), timeout=3))
def test_rpc(self):
async def f():
rpc_responses = iter([
("dump_tunnels_state", {
"tunnels": [TUNNEL_MODEL_BOARD_DATA]
}),
(
"create_tunnel",
{
"tunnel":
TUNNEL_MODEL_RELAY_DATA,
"tunnels": [
TUNNEL_MODEL_BOARD_DATA,
TUNNEL_MODEL_RELAY_DATA,
],
},
),
(
"create_tunnel",
{
"tunnel": TUNNEL_MODEL_BOARD_DATA,
"tunnels": [TUNNEL_MODEL_BOARD_DATA],
},
),
])
async def _rpc_command_cb(msg: RPCCommand):
name, resp = next(rpc_responses)
self.assertEqual(msg.name, name)
await msg.respond(resp)
with ExitStack() as stack:
stack.enter_context(
patch.object(self, "_rpc_command_cb", _rpc_command_cb))
stack.enter_context(patch.object(settings, "IS_RELAY", False))
async with AgileMeshNetworkManager(
ryu_ev_loop_scheduler=self.ryu_ev_loop_scheduler
) as manager:
manager.start_initialization()
await manager._initialization_task
self.assertDictEqual({}, manager._tunnel_creation_tasks)
# Don't attempt to connect to unknown macs.
manager.ask_for_tunnel(UNK_MAC)
self.assertDictEqual({}, manager._tunnel_creation_tasks)
# Connect to a switch, ensure that the task is cleaned up.
manager.ask_for_tunnel(SECOND_MAC)
await next(iter(manager._tunnel_creation_tasks.values()))
self.assertDictEqual({}, manager._tunnel_creation_tasks)
# Send a broadcast
await next(iter(self.rpc_server.sessions)).issue_broadcast(
"tunnel_created",
{
"tunnel": TUNNEL_MODEL_RELAY_DATA,
"tunnels": [TUNNEL_MODEL_RELAY_DATA],
},
)
await asyncio.sleep(0.001)
# TODO unknown tunnels after resync are dropped via RPC
expected_event_calls = [
# Initialization list:
[TunnelModel.from_dict(TUNNEL_MODEL_BOARD_DATA)],
# Initialization relay tunnel:
[
TunnelModel.from_dict(TUNNEL_MODEL_BOARD_DATA),
TunnelModel.from_dict(TUNNEL_MODEL_RELAY_DATA),
],
# ask_for_tunnel:
[TunnelModel.from_dict(TUNNEL_MODEL_BOARD_DATA)],
# Broadcast:
[TunnelModel.from_dict(TUNNEL_MODEL_RELAY_DATA)],
]
for (args, kwargs), ev_expected in zip_equal(
self.ryu_ev_loop_scheduler.send_event_to_observers.
call_args_list,
expected_event_calls,
):
ev = args[0]
self.assertListEqual(
sorted(t for t, _ in ev.mac_to_tunswitch.values()),
sorted(ev_expected),
)
self.loop.run_until_complete(asyncio.wait_for(f(), timeout=3))
def test_flows(self):
async def f():
async with AgileMeshNetworkManager(
ryu_ev_loop_scheduler=self.ryu_ev_loop_scheduler
) as manager:
manager.start_initialization()
# TODO missing flows from RPC sync are added
# TODO after packet in a tunnel creation request is sent
# TODO after tunnel creation a flow is set up
pass
self.loop.run_until_complete(asyncio.wait_for(f(), timeout=3))
class TestShop(unittest.TestCase):
def setUp(self):
"""
Prepare the test envirement.
start the server to mockup the database
"""
self.server = MockupDB(auto_ismaster=True, verbose=True)
self.server.run()
app.testing = True
app.config['MONGO_URI'] = self.server.uri
self.app = app.test_client()
self.token = mock_access_token()['access_token']
self.auth_header = {'Authorization': 'Bearer {}'.format(self.token)}
def tearDown(self):
self.server.stop()
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_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_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_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 mockdbserver(loop):
server = MockupDB()
server.run()
yield server
server.stop()
class functionsTest(unittest.TestCase):
def setUp(self):
self.server = MockupDB(auto_ismaster={"maxWireVersion": 3})
self.server.run()
#self.testConf['mongo_url'] =
self.testConf = {
"mongo_url" : self.server.uri,
"host_url": "https://lmp.nupursjsu.net",
"host" : "127.0.0.1",
"port" : 8080
}
def tearDown(self):
self.server.stop()
def test_display_userdetails(self):
user_details = {'userId': 'user1', 'firstName': 'myFirstName', 'lastName': 'myLastName', 'age': 20}
userId = "user1"
details = go(display_userdetails, userId, self.testConf)
query = OpQuery({"userId": "user1"}, namespace="Books.myapp_user", fields={"_id": False})
request = self.server.receives(query)
request.reply(user_details)
output = details()
for key in output:
if key in user_details:
self.assertEqual(user_details[key], output[key])
def test_display_bookdetails(self):
book_details = {'userId': 'user1', 'firstName': 'myFirstName', 'lastName': 'myLastName', 'age': 20}
userId = "user1"
details = go(display_userdetails, userId, self.testConf)
query = OpQuery({"userId": "user1"}, namespace="Books.myapp_user", fields={"_id": False})
request = self.server.receives(query)
request.reply(book_details)
output = details()
for key in output:
if key in book_details:
self.assertEqual(book_details[key], output[key])
def test_update_bookdetails(self):
book_details = {'userId': 'user1', 'firstName': 'myFirstName', 'lastName': 'myLastName', 'age': 20}
userId = "user1"
details = go(display_userdetails, userId, self.testConf)
query = OpQuery({"userId": "user1"}, namespace="Books.myapp_user", fields={"_id": False})
request = self.server.receives(query)
request.reply(book_details)
output = details()
for key in output:
if key in book_details:
self.assertEqual(book_details[key], output[key])
def test_update_userdetails(self):
user_details = {'userId': 'user1', 'firstName': 'myFirstName', 'lastName': 'myLastName', 'age': 20}
userId = "user1"
details = go(display_userdetails, userId, self.testConf)
query = OpQuery({"userId": "user1"}, namespace="Books.myapp_user", fields={"_id": False})
request = self.server.receives(query)
request.reply(user_details)
output = details()
for key in output:
if key in user_details:
self.assertEqual(user_details[key], output[key])
class GetDataSourceTestCase(unittest.TestCase):
@classmethod
def setUpClass(self):
self.server = MockupDB(auto_ismaster=True, verbose=True)
self.server.run()
# create mongo connection to mock server
app.testing = True
app.config['MONGO_URI'] = self.server.uri
self.app = app.test_client()
@classmethod
def tearDownClass(self):
self.server.stop()
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_getDataSource_404(self):
id = '5a8f1e368f7936badfbb0cfb'
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': []})
# act
http_response = future()
# assert
self.assertEqual(http_response.status_code, 404)
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_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_deleteDataSource(self):
# arrange
id = '5a8f1e368f7936badfbb0cfa'
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': 1})
# act
http_response = future()
# assert
self.assertIn(f'deleted {id}', http_response.get_data(as_text=True))
self.assertEqual(http_response.status_code, 202)
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)
class MockupDBFlaskTest(unittest.TestCase):
def setUp(self):
self.server = MockupDB(auto_ismaster=True)
self.server.run()
self.app = create_app(self.server.uri).test_client()
def tearDown(self):
self.server.stop()
def mock_db_get(self, url=None):
# dateStr = "2018-11-11T00:00:00.000Z"
# date = dateutil.parser.parse(dateStr)
request = self.server.receives(
OpMsg('find', 'urls', filter={'shorturl': url}))
request.ok(cursor={'id': 0, 'firstBatch': [mapping_dict[url]]})
def mock_db_update(self):
request = self.server.pop().reply({"modified_count": 1})
def mock_db_get_many(self, url=None):
request = self.server.pop()
# request = self.server.receives(
# OpMsg({"count": "urls", "query": {"shorturl": url}}))
request.ok(cursor={
'id': 0,
'firstBatch': [mapping_dict[url]],
'count': 1
})
def test_get_url_not_empty(self):
future = go(self.app.get, "/urls/e5a53874fbde55")
self.mock_db_get(url="e5a53874fbde55")
self.mock_db_update()
http_response = future()
# print http_response.status
# print http_response.mimetype
# print http_response.response
# print http_response.get_data()
self.assertEqual(("Long url is : newlonnnn44\n"),
http_response.get_data())
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())
def test_get_access_time_all(self):
future = go(self.app.get, "/urls/alltime_access/e5a53874fbde55")
self.mock_db_get_many(url="e5a53874fbde55")
http_response = future()
self.assertEqual(
"Access times for url: 'e5a53874fbde55'; for time duration: ' all' is: 1\n",
http_response.get_data())
class SignInTest(unittest.TestCase):
def setUp(self):
self.server = MockupDB(auto_ismaster=True, verbose=True)
self.server.run()
app.testing = True
app.config['MONGO_URI'] = self.server.uri
self.app = app.test_client()
def tearDown(self):
self.server.stop()
def test_delete_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': [USER]})
self.server.receives().ok()
request = self.server.receives(USER_REQ)
request.ok(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(future().status_code, 204)
def test_nonadmin_delete(self):
user = {
"_id": "5b37fff8bbf300b7ef185042",
"login": "******",
"password": "******",
"role": "regular"
}
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"
})
self.assertEqual(future().status_code, 401)
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_valid_client_success(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': []})
self.server.receives().ok({"_id":USER["_id"]})
self.assertEqual(future().status_code, 201)
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_signup_with_invalid_client(self):
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': []})
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_update_invalid_email(self):
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.put, '/auth/signup', headers=headers, json={
"userID": '',
"login": "******",
"password": "******",
"client_id": "midleware1",
"client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"
})
self.assertEqual(future().status_code, 400)
def test_update_invalid_user(self):
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.put, '/auth/signup', headers=headers, json={
"userID": '',
"login": "******",
"password": "******",
"client_id": "midleware1",
"client_secret": "1sfg135df1d32fsdf489d7q6sdq6s4d"
})
self.server.receives().ok(cursor={'id': 0, 'firstBatch': []})
self.assertEqual(future().status_code, 400)
def test_update_valid(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.put, '/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': [USER]})
self.server.receives().ok()
self.assertEqual(future().status_code, 400)
