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__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_user__invalid__type(self):
l.log(self.dbg, "entering: test__add_user__invalid__type")
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 type")
_type = "".join([
random.choice(string.ascii_letters + string.digits) for _ in range(100)
])
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 the user wasn't successfully created")
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_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(_))
