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(_))
