def login_user(params, _id, conn, logger, config, session): try: # NOTE: calculate user_id user_id = params.get( "user_id", ludeim.generate_user_user_id(params["username"], params["password_hash"])) with conn: # NOTE: get a lock on the database conn.execute("BEGIN EXCLUSIVE") # NOTE: get the user's type user = db.load_user_w_user_id(conn, user_id, _id) # NOTE: add the user's user_id to the session session["user_id"] = user.user_id # NOTE: add the user's type to the session session["type"] = user.type # NOTE: add user uuid to the session session["uuid"] = user.uuid return rpc.make_success_resp(user.one_hot_jsonify(), _id) except WrappedErrorResponse as e: file_logger.log_error({ "method": "login_user" + str(e.methods), "params": params, "error": str(e.exception) }) return e.response_obj except Exception as e: file_logger.log_error({ "method": "login_user", "params": params, "error": str(e) }) return rpc.make_error_resp(const.INTERNAL_ERROR_CODE, const.INTERNAL_ERROR, _id)
def test__add_user__invalid__username_collision(self): l.log(self.dbg, "entering: test__add_user__invalid__username_collision") 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_original = random.choice(lconst.USER_TYPES) username_original = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_USERNAME_LEN, lconst.MAX_USERNAME_LEN) ) ]) password_hash_original = "".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_original, password_hash_original) payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type_original, "username": username_original, "password_hash": password_hash_original }, "id": 1 } self.app.post(endpoint, json=payload) _type_changed = random.choice(lconst.USER_TYPES) password_hash_changed = "".join([ random.choice(string.ascii_letters + string.digits) for _ in range( random.randint(lconst.MIN_PASSWORD_HASH_LEN, lconst.MAX_PASSWORD_HASH_LEN) ) ]) l.log(self.dbg, "\tadding a user with the same username") payload = { "jsonrpc": "2.0", "method": "add_user", "params": { "type": _type_changed, "username": username_original, "password_hash": password_hash_changed }, "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") # TODO: implement replacement test # self.assertEqual(db.get_connection().execute("""SELECT * FROM users""").fetchall(), # [(derived_uuid, _type_original, username_original, password_hash_original, lconst.DEFAULT_USER_AVATAR, '[]', '[]')], # "database didn't update correctly") 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 __init__(self, uuid=None, user_id=None, _type=None, username=None, password_hash=None, avatar=None, location_uuids=None, item_uuids=None, incoming_item_uuids=None, outgoing_item_uuids=None): if _type is None: raise Exception("`type` can't be None.") self.type = _type if username is None: raise Exception("`username` can't be None.") self.username = username if password_hash is None: raise Exception("`password_hash` can't be None.") self.password_hash = password_hash if uuid is None: uuid = uuid4().hex + uuid4().hex + uuid4().hex + uuid4().hex self.uuid = uuid if user_id is None: user_id = ludeim.generate_user_user_id(self.username, self.password_hash) else: assert user_id == hashlib.sha256( (username + password_hash).encode("utf-8")).hexdigest() self.user_id = user_id if avatar is None: avatar = lconst.DEFAULT_USER_AVATAR self.avatar = avatar if location_uuids is None: location_uuids = set() self.location_uuids = location_uuids if item_uuids is None: item_uuids = set() self.item_uuids = item_uuids if incoming_item_uuids is None: incoming_item_uuids = set() self.incoming_item_uuids = incoming_item_uuids if outgoing_item_uuids is None: outgoing_item_uuids = set() self.outgoing_item_uuids = outgoing_item_uuids
def __init__(self, user_id=None, username=None, password_hash=None, avatar=None): if username is None: raise Exception("`username` can't be None.") self.username = username if password_hash is None: raise Exception("`password_hash` can't be None.") self.password_hash = password_hash if user_id is None: user_id = ludeim.generate_user_user_id(self.username, self.password_hash) else: assert user_id == hashlib.sha256( (username + password_hash).encode("utf-8")).hexdigest() self.user_id = user_id if avatar is None: avatar = lconst.DEFAULT_USER_AVATAR self.avatar = avatar
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(_))
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_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(_))
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__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_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__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__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__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_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_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 recalculate_user_id(self): self.user_id = ludeim.generate_user_user_id(self.username, self.password_hash)
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(_))