async def test_create_app_user(self):
resp = await self.fetch("/timestamp")
self.assertEqual(resp.code, 200)
resp = await self.fetch_signed("/user", signing_key=TEST_PRIVATE_KEY, method="POST",
body={'payment_address': TEST_PAYMENT_ADDRESS, 'is_app': True})
self.assertResponseCodeEqual(resp, 200)
body = json_decode(resp.body)
self.assertEqual(body['toshi_id'], TEST_ADDRESS)
async with self.pool.acquire() as con:
row = await con.fetchrow("SELECT * FROM users WHERE toshi_id = $1", TEST_ADDRESS)
self.assertIsNotNone(row)
self.assertTrue(row['is_bot'])
self.assertTrue(row['is_public'])
self.assertIsNotNone(row['username'])
# ensure we got a tracking event
self.assertEqual((await self.next_tracking_event())[0], encode_id(TEST_ADDRESS))
resp = await self.fetch_signed("/user", signing_key=TEST_PRIVATE_KEY, method="PUT",
body={'is_app': False})
async with self.pool.acquire() as con:
row = await con.fetchrow("SELECT * FROM users WHERE toshi_id = $1", TEST_ADDRESS)
self.assertIsNotNone(row)
self.assertFalse(row['is_bot'])
self.assertFalse(row['is_public'])
resp = await self.fetch_signed("/user", signing_key=TEST_PRIVATE_KEY, method="PUT",
body={'is_app': True})
async with self.pool.acquire() as con:
row = await con.fetchrow("SELECT * FROM users WHERE toshi_id = $1", TEST_ADDRESS)
self.assertIsNotNone(row)
self.assertTrue(row['is_bot'])
self.assertTrue(row['is_public'])
async def test_unchanged_username(self):
username = '******'
async with self.pool.acquire() as con:
await con.execute("INSERT INTO users (username, toshi_id) VALUES ($1, $2)", username, TEST_ADDRESS)
# make sure settings a username with the same eth address succeeds
body = {
"username": username,
"payment_address": TEST_PAYMENT_ADDRESS,
"name": "Bob Smith"
}
resp = await self.fetch_signed("/user", signing_key=TEST_PRIVATE_KEY, method="PUT", body=body)
self.assertResponseCodeEqual(resp, 200)
# ensure we got a tracking event
self.assertEqual((await self.next_tracking_event())[0], encode_id(TEST_ADDRESS))
async def test_transactions_with_known_sender_toshi_id(self):
body = {"from": FAUCET_ADDRESS, "to": TEST_ADDRESS, "value": 10**10}
resp = await self.fetch("/tx/skel", method="POST", body=body)
self.assertEqual(resp.code, 200)
tx = sign_transaction(json_decode(resp.body)['tx'], FAUCET_PRIVATE_KEY)
body = {"tx": tx}
resp = await self.fetch_signed("/tx",
signing_key=TEST_PRIVATE_KEY_2,
method="POST",
body=body)
self.assertEqual(resp.code, 200, resp.body)
# ensure we get a tracking events with a live id
self.assertEqual((await self.next_tracking_event())[0],
encode_id(TEST_ADDRESS_2))
tx_hash = json_decode(resp.body)['tx_hash']
async with self.pool.acquire() as con:
row = await con.fetch(
"SELECT * FROM transactions WHERE sender_toshi_id = $1",
FAUCET_ADDRESS)
self.assertEqual(len(row), 0)
row = await con.fetch(
"SELECT * FROM transactions WHERE sender_toshi_id = $1",
TEST_ADDRESS_2)
self.assertEqual(len(row), 1)
self.assertEqual(row[0]['from_address'], FAUCET_ADDRESS)
await self.wait_on_tx_confirmation(tx_hash)
async def test_report_user(self):
resp = await self.fetch_signed("/report", signing_key=TEST_PRIVATE_KEY, method="POST",
body={'toshi_id': TEST_ADDRESS_2})
self.assertResponseCodeEqual(resp, 204)
# ensure we get two tracking events
e1 = await self.next_tracking_event()
e2 = await self.next_tracking_event()
if e1[0] != encode_id(TEST_ADDRESS):
e1, e2 = e2, e1
self.assertEqual(e1[1], "Made report")
self.assertEqual(e2[1], "Was reported")
async with self.pool.acquire() as con:
row = await con.fetch("SELECT * FROM reports WHERE reporter_toshi_id = $1", TEST_ADDRESS)
self.assertEqual(len(row), 1)
self.assertEqual(row[0]['details'], None)
resp = await self.fetch_signed("/report", signing_key=TEST_PRIVATE_KEY, method="POST",
body={'toshi_id': TEST_ADDRESS_2})
self.assertResponseCodeEqual(resp, 204)
async with self.pool.acquire() as con:
row = await con.fetch("SELECT * FROM reports WHERE reporter_toshi_id = $1", TEST_ADDRESS)
self.assertEqual(len(row), 2)
resp = await self.fetch_signed("/report", signing_key=TEST_PRIVATE_KEY, method="POST",
body={'toshi_id': TEST_ADDRESS_3, 'details': ''})
self.assertResponseCodeEqual(resp, 204)
async with self.pool.acquire() as con:
row = await con.fetch("SELECT * FROM reports WHERE reportee_toshi_id = $1", TEST_ADDRESS_3)
self.assertEqual(len(row), 1)
self.assertEqual(row[0]['details'], '')
async def test_create_user(self):
resp = await self.fetch("/timestamp")
self.assertEqual(resp.code, 200)
resp = await self.fetch_signed("/user", signing_key=TEST_PRIVATE_KEY, method="POST",
body={'payment_address': TEST_PAYMENT_ADDRESS})
self.assertResponseCodeEqual(resp, 200)
body = json_decode(resp.body)
self.assertEqual(body['toshi_id'], TEST_ADDRESS)
async with self.pool.acquire() as con:
row = await con.fetchrow("SELECT * FROM users WHERE toshi_id = $1", TEST_ADDRESS)
self.assertIsNotNone(row)
self.assertFalse(row['is_bot'])
self.assertIsNotNone(row['username'])
self.assertIsNotNone(row['avatar'])
self.assertIsNotNone(
regex.match("\/[^\/]+\/public\/identicon\/{}\.png".format(TEST_PAYMENT_ADDRESS),
urllib.parse.urlparse(row['avatar']).path), row['avatar'])
async with self.boto:
objs = await self.boto.list_objects()
self.assertIn('Contents', objs)
self.assertEqual(len(objs['Contents']), 1)
resp = await self.fetch(row['avatar'], method="GET")
self.assertEqual(resp.code, 200, "Got unexpected {} for url: {}".format(resp.code, row['avatar']))
# ensure we got a tracking event
self.assertEqual((await self.next_tracking_event())[0], encode_id(TEST_ADDRESS))
async def test_create_user_with_username(self):
username = "******"
body = {
"username": username,
"payment_address": TEST_PAYMENT_ADDRESS,
"name": "Bob Smith"
}
resp = await self.fetch_signed("/user", signing_key=TEST_PRIVATE_KEY, method="POST", body=body)
self.assertResponseCodeEqual(resp, 200)
async with self.pool.acquire() as con:
row = await con.fetchrow("SELECT * FROM users WHERE username = $1", username)
self.assertIsNotNone(row)
self.assertEqual(row['username'], username)
# ensure we got a tracking event
self.assertEqual((await self.next_tracking_event())[0], encode_id(TEST_ADDRESS))
async def test_update_user_avatar(self):
capitalised = 'BobSmith'
async with self.pool.acquire() as con:
await con.execute(
"INSERT INTO users (username, toshi_id) VALUES ($1, $2)",
capitalised, TEST_ADDRESS)
boundary = uuid4().hex
headers = {
'Content-Type': 'multipart/form-data; boundary={}'.format(boundary)
}
png = blockies.create(TEST_PAYMENT_ADDRESS,
size=8,
scale=12,
format='PNG')
files = [('image.png', png)]
body = body_producer(boundary, files)
resp = await self.fetch_signed("/user",
signing_key=TEST_PRIVATE_KEY,
method="PUT",
body=body,
headers=headers)
self.assertResponseCodeEqual(resp, 200)
async with self.pool.acquire() as con:
urow = await con.fetchrow(
"SELECT * FROM users WHERE toshi_id = $1", TEST_ADDRESS)
self.assertIsNotNone(urow)
self.assertIsNotNone(urow['avatar'])
self.assertIsNotNone(
regex.match(
"\/[^\/]+\/public\/avatar\/{}_[a-f0-9]{{{}}}\.png".format(
TEST_ADDRESS, AVATAR_URL_HASH_LENGTH),
urllib.parse.urlparse(urow['avatar']).path), urow['avatar'])
first_avatar_url = urow['avatar']
resp = await self.fetch(first_avatar_url, method="GET")
self.assertEqual(
resp.code, 200,
"Got unexpected {} for url: {}".format(resp.code,
first_avatar_url))
# easy to test png, it doesn't change so easily when "double" saved
self.assertEqual(resp.body, png)
self.assertIn('Etag', resp.headers)
last_etag = resp.headers['Etag']
self.assertIn('Last-Modified', resp.headers)
last_modified = resp.headers['Last-Modified']
# try update with jpeg
jpeg = blockies.create(TEST_ADDRESS_2, size=8, scale=12, format='JPEG')
# rotate jpeg
# TODO: figure out if there's actually a way to test that
# this is working as expected
jpeg = Image.open(BytesIO(jpeg)).rotate(90)
stream = BytesIO()
# generate exif info for rotation
exif_dict = {
"0th": {
piexif.ImageIFD.XResolution: (jpeg.size[0], 1),
piexif.ImageIFD.YResolution: (jpeg.size[1], 1),
piexif.ImageIFD.Orientation: 8
}
}
jpeg.save(stream, format="JPEG", exif=piexif.dump(exif_dict))
jpeg = stream.getbuffer().tobytes()
files = [('image.jpg', jpeg)]
body = body_producer(boundary, files)
resp = await self.fetch_signed("/user",
signing_key=TEST_PRIVATE_KEY,
method="PUT",
body=body,
headers=headers)
self.assertResponseCodeEqual(resp, 200)
# ensure we got a tracking event
self.assertEqual((await self.next_tracking_event())[0],
encode_id(TEST_ADDRESS))
async with self.pool.acquire() as con:
urow = await con.fetchrow(
"SELECT * FROM users WHERE toshi_id = $1", TEST_ADDRESS)
self.assertIsNotNone(urow)
self.assertIsNotNone(urow['avatar'])
self.assertIsNotNone(
regex.match(
"\/[^\/]+\/public\/avatar\/{}_[a-f0-9]{{{}}}\.jpg".format(
TEST_ADDRESS, AVATAR_URL_HASH_LENGTH),
urllib.parse.urlparse(urow['avatar']).path))
jpg_avatar_url = urow['avatar']
resp = await self.fetch(jpg_avatar_url,
method="GET",
headers={
'If-None-Match': last_etag,
'If-Modified-Since': last_modified
})
self.assertResponseCodeEqual(resp, 200)
# it's impossible to compare the jpegs after being saved a 2nd time
# so i simply make sure the value isn't the same as the png
self.assertNotEqual(resp.body, png)
# check for 304 when trying with new values
# NOTE (TODO): moto_server doesn't return 304, but s3 itself does
# resp304 = await self.fetch(jpg_avatar_url, method="GET", headers={
# 'If-None-Match': resp.headers['Etag'],
# 'If-Modified-Since': resp.headers['Last-Modified']
# })
# self.assertResponseCodeEqual(resp304, 304)
# check that avatar stays after other update
presp = await self.fetch_signed("/user",
signing_key=TEST_PRIVATE_KEY,
method="PUT",
body={
"username": "******",
"name": "Jamie"
})
self.assertResponseCodeEqual(presp, 200)
data = json_decode(presp.body)
self.assertEqual(data['avatar'], jpg_avatar_url)
# make sure the original url is still available
resp = await self.fetch(first_avatar_url, method="GET")
self.assertResponseCodeEqual(resp, 200)
self.assertEqual(resp.body, png)
async with self.boto:
objs = await self.boto.list_objects()
self.assertIn('Contents', objs)
self.assertEqual(len(objs['Contents']), 2)
def test_encode_id(self):
digest = analytics.encode_id(TEST_ADDRESS)
self.assertEqual(TEST_ADDRESS_DIGEST, digest)