def test__add_user__invalid__long_password_hash(self): l.log(self.dbg, "entering: test__add_user__invalid__long_password_hash") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding a user with an invalid password hash") _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN) ) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MAX_PASSWORD_HASH_LEN+1, 10000) ) ]) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting the request failed") self.assertIn("error", resp.json, "api response was incorrect") self.assertEqual(db.get_connection().execute("""SELECT * FROM users""").fetchall(), [], "database didn't update correctly") l.log(self.dbg, "\tending round {}\n".format(_))
def test__add_item__valid__with_uuid(self): l.log(self.dbg, "entering: test__add_item__valid__with_uuid") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding a user") # NOTE: add a new user _type_1 = random.choice(lconst.USER_TYPES) username_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN) ) ]) password_hash_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN) ) ]) derived_user_id = ludeim.generate_user_user_id(username_1, password_hash_1) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type_1, "username": username_1, "password_hash": password_hash_1 }, "id": 1 } self.app.post(endpoint, json=payload) l.log(self.dbg, "\tlogin to the user") # NOTE: login to the new user payload = { "jsonrpc": "2.0", "method": "login_user", "params": { "username": username_1, "password_hash": password_hash_1 }, "id": 1 } self.app.post(endpoint, json=payload) l.log(self.dbg, "\tadding a location to the user") # NOTE: add a location to that new user _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 50) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float(random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for latitude longitude = float(random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "user_id": derived_user_id, "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } self.app.post(endpoint, json=payload) l.log(self.dbg, "\tgetting the location's a uuid") # NOTE: get the user's location's uuid payload = { "jsonrpc": "2.0", "method": "get_user_location_uuids", "params": { }, "id": 1 } # try: resp = self.app.post(endpoint, json=payload) # except Exception as e: # print(e.with_traceback()) resp = resp.json l.log(self.dbg, "\tadding an item to this user's location") # NOTE: add an item to the new user at this location payload = { "jsonrpc": "2.0", "method": "add_item", "params": { "location_uuid": resp["result"][0] }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting the item was created and added") db_dump = db.get_connection().execute("""SELECT * FROM items""").fetchall() self.assertEqual(len(db_dump), 1, "database didn't update correctly") # TODO: implement replacement test # self.assertEqual(db_dump[0][1:], # (lconst.DIAMOND, # json.dumps((payload["params"]["location_uuid"],)), # json.dumps((derived_user_id,)), # lconst.STATIONARY), # "database didn't update correctly") l.log(self.dbg, "\tending round {}\n".format(_))
def test__add_user__valid__batch(self): l.log(self.dbg, "entering: test__add_user__valid__batch") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding 25 users in a single batch request") payloads = [] for i in range(25): _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN) ) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN) ) ]) derived_user_id = ludeim.generate_user_user_id(username, password_hash) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": i } payloads.append(payload) resp = self.app.post(endpoint, json=payloads) resps = json.loads(resp.data.decode("utf-8")) l.log(self.dbg, "\tasserting all 25 users were made") for r in resps: self.assertIn("result", r, "error response") db_dump = db.get_connection().execute("""SELECT * FROM users""").fetchall() self.assertEqual(len(db_dump), 25, "database didn't update correctly") l.log(self.dbg, "\tending round {}\n".format(_))
async def test(): _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id = ludeim.generate_user_user_id( username, password_hash) await (session.post(url=url, json={ "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 })) l.log(self.dbg, "\tadding 10 locations asynchronously") resps = [] for _ in range(10): _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50 ) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for latitude longitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "user_id": derived_user_id, "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } resps.append(session.post(url=url, json=payload)) for i in range(len(resps)): resps[i] = await resps[i] resps = [r.json() for r in resps] acc = True for r in resps: acc = acc and "result" in r l.log(self.dbg, "\tasserting all locations were added") self.assertTrue(acc, msg="a request errored") db_resp = db.get_connection().execute( """SELECT * FROM locations""").fetchall() self.assertEqual( len(db_resp), 10, "not all locations got saved to the database")
def test__add_location__invalid__representative_title(self): l.log(self.dbg, "entering: test__add_location__invalid__representative_title") for _ in range( 10): # NOTE: run 100 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding a user") _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id = ludeim.generate_user_user_id( username, password_hash) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 } self.app.post(endpoint, json=payload) # NOTE: login to the new user l.log(self.dbg, "\tlogin to the user") payload = { "jsonrpc": "2.0", "method": "login_user", "params": { "username": username, "password_hash": password_hash }, "id": 1 } self.app.post(endpoint, json=payload) l.log(self.dbg, "\tadding a location with an invalid representative title") _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float( random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for latitude longitude = float( random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(0, 100) # TODO: formalize bounds for details ) ]) rep_title = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range(random.randint(50, 100)) ]) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting the location wasn't added") self.assertIn("error", resp.json, "api response was incorrect") db_dump = db.get_connection().execute( """SELECT * FROM locations""").fetchall() self.assertEqual(db_dump, [], "database inadvertently updated") l.log(self.dbg, "\tending round {}\n".format(_))
def test__put_sess__valid(self): l.log(self.dbg, "entering: test__put_sess__valid") for _ in range(10): # NOTE: run 100 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the application") self.setUp() # NOTE: reset client to prevent carry over sessions l.log(self.dbg, "\tupdating the session") payload = { "jsonrpc": "2.0", "method": "put_sess", "params": { "user_id": "dummy_user_id", "key": "".join([ random.choice(string.ascii_letters + string.digits) for _ in range(128) ]), "value": "".join([ random.choice(string.ascii_letters + string.digits) for _ in range(128) ]) }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting session updated correctly") self.assertIn("result", json.loads(resp.data.decode("utf-8")), "response was an error") with self.app as c: with c.session_transaction() as sess: self.assertEqual(sess.get(payload["params"]["key"], None), payload["params"]["value"], "session did not update properly") l.log(self.dbg, "\tending round {}\n".format(_))
def test__add_location__valid__async_with_uuid(self): l.log(self.dbg, "entering: test__add_location__valid__async_with_uuid") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding a user") def ex(w): os.dup2(w.fileno(), 1) app.app.run() a, b = multiprocessing.Pipe() p = multiprocessing.Process(target=ex, args=(a, )) log = logging.getLogger('werkzeug') log.disabled = True p.start() time.sleep(2) url = "http://" + "127.0.0.1:5000" + endpoint session = AsyncSession(n=100) async def test(): _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id = ludeim.generate_user_user_id( username, password_hash) await (session.post(url=url, json={ "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 })) l.log(self.dbg, "\tadding 10 locations asynchronously") resps = [] for _ in range(10): _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50 ) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for latitude longitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "user_id": derived_user_id, "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } resps.append(session.post(url=url, json=payload)) for i in range(len(resps)): resps[i] = await resps[i] resps = [r.json() for r in resps] acc = True for r in resps: acc = acc and "result" in r l.log(self.dbg, "\tasserting all locations were added") self.assertTrue(acc, msg="a request errored") db_resp = db.get_connection().execute( """SELECT * FROM locations""").fetchall() self.assertEqual( len(db_resp), 10, "not all locations got saved to the database") try: session.run(test) except twisted.internet.error.ReactorNotRestartable: pass except SystemExit: # NOTE: requests_threads is experimental and currently always exits with a hard sys exit pass p.kill() l.log(self.dbg, "\tending round {}\n".format(_))
def test__login__valid__without_logout(self): l.log(self.dbg, "entering: test__login__valid__without_logout") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tresetting the application") self.setUp() # NOTE: reset client to prevent carry over sessions l.log(self.dbg, "\tadding a user") _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id = ludeim.generate_user_user_id( username, password_hash) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 } resp = self.app.post(endpoint, json=payload) expected_resp = { "jsonrpc": "2.0", "result": { "type": _type, "user_id": derived_user_id }, "id": 1 } l.log(self.dbg, "\tchecking that the user was created correctly") self.assertEqual(json.loads(resp.data.decode("utf-8")), expected_resp, "api response was incorrect") # TODO: implement replacement test # self.assertEqual(db.get_connection().execute("""SELECT * FROM users""").fetchall(), # [(derived_uuid, _type, username, password_hash, lconst.DEFAULT_USER_AVATAR, '[]', '[]')], # "database didn't update correctly") with self.app as c: with c.session_transaction() as sess: self.assertEqual( sess.get("user_id", None), None, "user_id not cleared from session correctly") self.assertEqual( sess.get("type", None), None, "type not cleared from session correctly") # NOTE: logging into the new user l.log(self.dbg, "\tlogging into the newly created user") payload = { "jsonrpc": "2.0", "method": "login_user", "params": { "username": username, "password_hash": password_hash }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting that login worked correctly") self.assertIn("result", resp.json, "api response was incorrect") # TODO: implement replacement test # self.assertEqual(db.get_connection().execute("""SELECT * FROM users""").fetchall(), # [(derived_uuid, _type, username, password_hash, lconst.DEFAULT_USER_AVATAR, '[]', '[]')], # "database didn't update correctly") with self.app as c: with c.session_transaction() as sess: self.assertEqual( sess["user_id"], derived_user_id, "user_id not saved in the session correctly during login" ) self.assertEqual( sess["type"], _type, "type not saved in the session correctly during login") l.log(self.dbg, "\tending round {}\n".format(_))
def test__add_location__valid__batch_with_uuid(self): l.log(self.dbg, "entering: test__add_location__valid__batch_with_uuid") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding a user") _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id = ludeim.generate_user_user_id( username, password_hash) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 } self.app.post(endpoint, json=payload) l.log(self.dbg, "\tadding 25 locations at once with a batch request") payloads = [] expected_results = [] for i in range(25): _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for latitude longitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "user_id": derived_user_id, "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": i } payloads.append(payload) resp = self.app.post(endpoint, json=payloads) resps = json.loads(resp.data.decode("utf-8")) l.log(self.dbg, "\tasserting all the locations were added") for r in resps: self.assertIn("result", r, "error response") db_dump = db.get_connection().execute( """SELECT * FROM locations""").fetchall() self.assertEqual(len(db_dump), 25, "database didn't update correctly") l.log(self.dbg, "\tending round {}\n".format(_))
def test__get_sess_valid(self): l.log(self.dbg, "entering: test__get_sess_valid") for _ in range( 10): # NOTE: run 100 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database # NOTE: add a user l.log(self.dbg, "\tadding a user") _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id = ludeim.generate_user_user_id( username, password_hash) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 } self.app.post(endpoint, json=payload) # NOTE: login to the new user l.log(self.dbg, "\tlogging in") payload = { "jsonrpc": "2.0", "method": "login_user", "params": { "username": username, "password_hash": password_hash }, "id": 1 } self.app.post(endpoint, json=payload) # NOTE: get the session & validate it l.log(self.dbg, "\tgetting the session") payload = { "jsonrpc": "2.0", "method": "get_sess", "params": {}, "id": 1 } resp = self.app.post(endpoint, json=payload) expected_result = {"user_id": derived_user_id, "type": _type} l.log(self.dbg, "\tasserting the returned session is correct") self.assertEqual( json.loads(resp.data.decode("utf-8"))["result"], expected_result, "returned session didn't match expectation") l.log(self.dbg, "\tending round {}\n".format(_))
def test__get_user_location_uuids__valid(self): l.log(self.dbg, "entering: test__get_user_location_uuids__valid") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding a user") _type_1 = random.choice(lconst.USER_TYPES) username_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id_1 = ludeim.generate_user_user_id( username_1, password_hash_1) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type_1, "username": username_1, "password_hash": password_hash_1 }, "id": 1 } self.app.post(endpoint, json=payload) l.log(self.dbg, "\tadding 10 random locations") for i in range(10): _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for latitude longitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "user_id": derived_user_id_1, "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tgetting the user's location uuids") payload = { "jsonrpc": "2.0", "method": "get_user_location_uuids", "params": { "user_id": derived_user_id_1, "username": username_1 }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting that 10 were returned") self.assertEqual( len(json.loads(resp.data.decode("utf-8"))["result"]), 10, "api response was incorrect") l.log(self.dbg, "\tending round {}\n".format(_))
def test__get_user_locations__valid__via_session(self): l.log(self.dbg, "entering: test__get_user_locations__valid__via_session", True) for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database # NOTE: add user 1 l.log(self.dbg, "\tadding user") _type_1 = random.choice(lconst.USER_TYPES) username_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id_1 = ludeim.generate_user_user_id( username_1, password_hash_1) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type_1, "username": username_1, "password_hash": password_hash_1 }, "id": 1 } self.app.post(endpoint, json=payload) # NOTE: login l.log(self.dbg, "\tlogging user in") payload = { "jsonrpc": "2.0", "method": "login_user", "params": { "username": username_1, "password_hash": password_hash_1 }, "id": 1 } self.app.post(endpoint, json=payload) # NOTE: add a few locations l.log(self.dbg, "\tadding 10 random locations to the user") for i in range(10): _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for latitude longitude = float( random.randint(1, 360) / random.randint( 1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "user_id": derived_user_id_1, "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } self.app.post(endpoint, json=payload) # NOTE: get them back l.log(self.dbg, "\tloading the user's locations") payload = { "jsonrpc": "2.0", "method": "get_user_locations", "params": {}, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting the response was not an error") self.assertIn("result", resp.json, "response was an error") l.log(self.dbg, "\tasserting the number of locations returned was 10") self.assertEqual(10, len(resp.json["result"]), "did not return the correct amount of locations") l.log(self.dbg, "\tending round {}\n".format(_))
def test__get_all_users__valid(self): l.log(self.dbg, "entering: test__get_all_usernames__valid") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding 25 users") for i in range(25): _type_1 = random.choice(lconst.USER_TYPES) username_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id = ludeim.generate_user_user_id( username_1, password_hash_1) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type_1, "username": username_1, "password_hash": password_hash_1 }, "id": 1 } self.app.post(endpoint, json=payload) l.log(self.dbg, "\tgetting all usernames in the system") payload = { "jsonrpc": "2.0", "method": "get_all_users", "params": { "user_id": derived_user_id }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting all 25 usernames are returned") results = json.loads(resp.data.decode("utf-8"))["result"] self.assertEqual(len(results), 25, "database and/or api error") # TODO: implement replacement test # for r in results: # self.assertIn(r, usernames, "unknown username returned") l.log(self.dbg, "\tending round {}\n".format(_))
def test__begin_transfer__valid(self): l.log(self.dbg, "entering: test__begin_transfer__valid") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tresetting the application") self.setUp() # NOTE: reset client to prevent carry over sessions l.log(self.dbg, "\tadding a user") # NOTE: adding user 1 _type_1 = random.choice(lconst.USER_TYPES) username_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash_1 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id_1 = ludeim.generate_user_user_id( username_1, password_hash_1) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type_1, "username": username_1, "password_hash": password_hash_1 }, "id": 1 } resp = self.app.post(endpoint, json=payload) # NOTE: adding user 2 l.log(self.dbg, "\tadding a second user") _type_2 = random.choice(lconst.USER_TYPES) username_2 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash_2 = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id_2 = ludeim.generate_user_user_id( username_2, password_hash_2) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type_2, "username": username_2, "password_hash": password_hash_2 }, "id": 1 } resp = self.app.post(endpoint, json=payload) # NOTE: login to user 1 l.log(self.dbg, "\tlogging into the first user") payload = { "jsonrpc": "2.0", "method": "login_user", "params": { "username": username_1, "password_hash": password_hash_1 }, "id": 1 } resp = self.app.post(endpoint, json=payload) # NOTE: add a location to user 1 l.log(self.dbg, "\tadding a location to the first user") _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float( random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for latitude longitude = float( random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "user_id": derived_user_id_1, "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } resp = self.app.post(endpoint, json=payload) # NOTE: add a location to user 2 l.log(self.dbg, "\tadding a location to user 2") _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float( random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for latitude longitude = float( random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "user_id": derived_user_id_2, "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tlooking up user 1's location's uuid") # NOTE: look up user 1's location's uuid payload = { "jsonrpc": "2.0", "method": "get_user_location_uuids", "params": {}, "id": 1 } resp = self.app.post(endpoint, json=payload) loc_uuid_1 = resp.json["result"][0] l.log(self.dbg, "\tadding a and item to user user 1 at it's only location") # NOTE: add an item payload = { "jsonrpc": "2.0", "method": "add_item", "params": { "location_uuid": loc_uuid_1 }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tlooking up the item's uuid") # NOTE: look up the item's uuid payload = { "jsonrpc": "2.0", "method": "get_user_item_uuids", "params": {}, "id": 1 } resp = self.app.post(endpoint, json=payload) item_uuid = resp.json["result"][0] l.log(self.dbg, "\tlooking up user 2's location uuids") # NOTE: look up user 2's location's uuid payload = { "jsonrpc": "2.0", "method": "get_user_location_uuids", "params": { "username": username_2 }, "id": 1 } resp = self.app.post(endpoint, json=payload) loc_uuid_2 = resp.json["result"][0] # NOTE: get all users payload = { "jsonrpc": "2.0", "method": "get_all_users", "params": {}, "id": 1 } resp = self.app.post(endpoint, json=payload) for user in resp.json["result"]: if user["username"] == username_2: dest_uuid_2 = user["uuid"] # NOTE: begin transfer l.log( self.dbg, "\tbeginning transfer from user 1's location to user 2's location" ) payload = { "jsonrpc": "2.0", "method": "begin_transfer", "params": { "item_uuid": item_uuid, "destination_location_uuid": loc_uuid_2, "destination_user_uuid": dest_uuid_2 }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting that the transfer has begun") self.assertIn("result", resp.json, "result was an error") l.log(self.dbg, "\tending round {}\n".format(_))
def test__add_user__valid(self): l.log(self.dbg, "entering: test__add_user__valid") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding a user") _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN) ) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN) ) ]) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting a user was added") self.assertIn("result", resp.json, "api response was incorrect") # TODO: implement replacement test # self.assertEqual(db.get_connection().execute("""SELECT * FROM users""").fetchall(), # [(derived_uuid, _type, username, password_hash, lconst.DEFAULT_USER_AVATAR, '[]', '[]')], # "database didn't update correctly") l.log(self.dbg, "\tending round {}\n".format(_))
def test__add_location__valid__with_uuid(self): l.log(self.dbg, "entering: test__add_location__valid__with_uuid") for _ in range( 10): # NOTE: run 100 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding a user") _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN)) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN)) ]) derived_user_id = ludeim.generate_user_user_id( username, password_hash) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 } self.app.post(endpoint, json=payload) l.log(self.dbg, "\tadding a location to the user") _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 50) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float( random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for latitude longitude = float( random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint( 5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "user_id": derived_user_id, "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting the location was successfully added") self.assertIn("result", resp.json, "api response was incorrect") db_dump = db.get_connection().execute( """SELECT * FROM locations""").fetchall() self.assertEqual(len(db_dump), 1, "database didn't update correctly") # TODO: implement replacement test # self.assertEqual(db_dump[0][1:-1], # (_type, json.dumps([derived_uuid]), '[]', name, address, latitude, longitude, details, # lconst.DEFAULT_LOCATION_AVATAR), # "database didn't update correctly") self.assertEqual(json.loads(db_dump[0][-1]), payload["params"]["representative"], "saved representative incorrect") l.log(self.dbg, "\tending round {}\n".format(_))
def test__add_user__valid__async(self): l.log(self.dbg, "entering: test__add_user__valid__async") for _ in range(10): # NOTE: run 10 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tadding 10 users asynchronously") def ex(w): os.dup2(w.fileno(), 1) app.app.run() a, b = multiprocessing.Pipe() p = multiprocessing.Process(target=ex, args=(a,)) log = logging.getLogger('werkzeug') log.disabled = True p.start() time.sleep(2) # SOURCE: https://stackoverflow.com/questions/9110593/asynchronous-requests-with-python-requests def ex_handler(request, exception): print("the exception failed. that sucks.") print(request) print(exception) reqs = [] url = "http://" + "127.0.0.1:5000" + endpoint for _ in range(10): _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN) ) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN) ) ]) reqs.append(grequests.post(url=url, data=json.dumps({ "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 }))) resps = grequests.map(reqs, exception_handler=ex_handler) p.kill() resps = [r.json() for r in resps] acc = True for r in resps: acc = acc and "result" in r l.log(self.dbg, "\tasserting all 10 users were made") self.assertTrue(acc, msg="a request errored") db_resp = db.get_connection().execute("""SELECT * FROM users""").fetchall() self.assertEqual(len(db_resp), 10, "not all users got saved to the database") l.log(self.dbg, "\tending round {}\n".format(_))
def test__get_location__valid(self): l.log(self.dbg, "entering: test__get_location__valid") for _ in range(10): # NOTE: run 100 random iterations to for robustness l.log(self.dbg, "\tstarting round {}".format(_)) l.log(self.dbg, "\tresetting the database") reset.auto_reset() # NOTE: reset the database l.log(self.dbg, "\tresetting the application") self.setUp() # NOTE: reset client to prevent carry over sessions l.log(self.dbg, "\tadding a user") # NOTE: adding a user _type = random.choice(lconst.USER_TYPES) username = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN) ) ]) password_hash = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN) ) ]) derived_user_id = ludeim.generate_user_user_id(username, password_hash) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type, "username": username, "password_hash": password_hash }, "id": 1 } self.app.post(endpoint, json=payload) # NOTE: login to the user l.log(self.dbg, "\tlogging into the user") payload = { "jsonrpc": "2.0", "method": "login_user", "params": { "username": username, "password_hash": password_hash }, "id": 1 } self.app.post(endpoint, json=payload) # NOTE: add a location to that user l.log(self.dbg, "\tadding a location to the user") _type = random.choice(lconst.LOCATION_TYPES) name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 50) # TODO: formalize bounds for location names ) ]) address = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 50) # TODO: formalize bounds for addresses ) ]) latitude = float(random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for latitude longitude = float(random.randint(1, 360) / random.randint(1, 360)) # TODO: formalize bounds for longitude details = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(0, 100) # TODO: formalize bounds for details ) ]) rep_title = random.choice(lconst.TITLES) rep_first_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for first names ) ]) rep_last_name = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for last names ) ]) rep_contact_info = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(5, 20) # TODO: formalize bounds for contact info ) ]) payload = { "jsonrpc": "2.0", "method": "add_location", "params": { "type": _type, "name": name, "address": address, "latitude": latitude, "longitude": longitude, "details": details, "representative": { "title": rep_title, "first_name": rep_first_name, "last_name": rep_last_name, "contact_info": rep_contact_info } }, "id": 1 } self.app.post(endpoint, json=payload) # NOTE: look up the user's location uuids l.log(self.dbg, "\tlooking up the user's location uuids") payload = { "jsonrpc": "2.0", "method": "get_user_location_uuids", "params": {}, "id": 1 } resp = self.app.post(endpoint, json=payload) loc_uuid = resp.json["result"][0] # NOTE: look up the location based on uuid and compared to expected l.log(self.dbg, "\tlooking up the location based on the uuid") payload = { "jsonrpc": "2.0", "method": "get_location", "params": { "location_uuid": loc_uuid }, "id": 1 } resp = self.app.post(endpoint, json=payload) l.log(self.dbg, "\tasserting the response is not an error") self.assertIn("result", resp.json, "returned no error") l.log(self.dbg, "\tending round {}\n".format(_))