async def test_update_user_duplicate_email(self):
expected_new_email = USER_WITH_NO_ACCOUNTS_EMAIL
new_user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
new_user.email = expected_new_email
with self.assertRaises(DuplicateEntity):
updated_user = await self.backend.update_user(new_user)
async def test_update_user_duplicate_email(self):
expected_new_email = USER_WITH_NO_ACCOUNTS_EMAIL
new_user_data = {"email": expected_new_email}
resp = await self.client.patch(
f"/users/{USER_WITH_MULTIPLE_ACCOUNTS_ID}",
headers={
"Authorization": f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
json=new_user_data,
)
self.assertEqual(HTTPStatus.ACCEPTED, resp.status)
user_data = await resp.json()
new_user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
new_user.name = expected_new_email
expected_error_message = """ERROR: duplicate key value violates unique constraint "user_tx_email_key"\nDETAIL: Key (tx_email)=([email protected]) already exists.\n"""
self.assertEqual(
ErrorResource(
errors=[ErrorDetail(msg=expected_error_message)]
).dict(),
user_data,
)
resp = await self.client.get(
f"/users/{USER_WITH_MULTIPLE_ACCOUNTS_ID}",
headers={
"Authorization": f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
updated_user_data = await resp.json()
self.assertEqual(
UserResource(user=User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)).dict(),
updated_user_data,
)
async def test_update_user_update_all_fields(self):
expected_new_name = "Novo Nome"
expected_new_email = "*****@*****.**"
new_user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
new_user.name = expected_new_name
new_user.email = expected_new_email
resp = await self.client.patch(
f"/users/{USER_WITH_MULTIPLE_ACCOUNTS_ID}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
json=new_user.dict(),
)
self.assertEqual(HTTPStatus.ACCEPTED, resp.status)
user_data = await resp.json()
self.assertEqual(UserResource(user=new_user).dict(), user_data)
resp = await self.client.get(
f"/users/{USER_WITH_MULTIPLE_ACCOUNTS_ID}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
updated_user_data = await resp.json()
self.assertEqual(UserResource(user=new_user).dict(), updated_user_data)
async def test_delete_user_user_with_accounts(self):
resp = await self.client.delete(
f"/users/{USER_WITH_MULTIPLE_ACCOUNTS_ID}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
self.assertEqual(200, resp.status)
resp_data = await resp.json()
self.assertEqual(
UserResource(user=User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)).dict(),
resp_data,
)
other_users = await self.client.get(
f"/users",
headers={
"Authorization": f"Token {USER_WITH_ONE_ACCOUNT_AUTH_KEY}"
},
)
other_users_data = await other_users.json()
self.assertCountEqual(
UserListResource(users=[
User(**USER_WITH_NO_ACCOUNTS_DICT),
User(**USER_WITH_ONE_ACCOUNT_DICT),
]).dict(),
other_users_data,
)
async def test_create_user_OK(self):
user_name = "New User"
user_email = "*****@*****.**"
user_created = await self.backend.create_user(
User(name=user_name, email=user_email)
)
self.assertEqual(
user_created, User(id=1, name=user_name, email=user_email)
)
async def setUp(self):
await super(AccountEndpointsTest, self).setUp()
self.account_dev = Account(**ACCOUNT_DEV_DICT)
self.account_infra = Account(**ACCOUNT_INFRA_DICT)
self.user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
self.user_with_one_account = User(**USER_WITH_ONE_ACCOUNT_DICT)
async def test_get_all_users(self):
users = await self.backend.get_users()
self.assertCountEqual(
[
User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT),
User(**USER_WITH_ONE_ACCOUNT_DICT),
User(**USER_WITH_NO_ACCOUNTS_DICT),
],
users,
)
async def test_accounts_remove_from_account_user_already_in_account(self):
account = Account(**ACCOUNT_DEV_DICT)
user = User(**USER_WITH_ONE_ACCOUNT_DICT)
self.assertTrue(await account.user_has_permission(user))
await self.backend.remove_user(user, account)
self.assertFalse(await account.user_has_permission(user))
account2 = Account(**ACCOUNT_INFRA_DICT)
self.assertTrue(await account2.user_has_permission(
User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)))
async def test_accounts_get_users_account_has_users(self):
account = Account(**ACCOUNT_DEV_DICT)
users = await self.backend.get_users_from_account(account)
self.assertEqual(2, len(users))
self.assertEqual(
[
User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT),
User(**USER_WITH_ONE_ACCOUNT_DICT),
],
users,
)
async def test_update_user_update_name(self):
expected_new_email = "*****@*****.**"
new_user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
new_user.email = expected_new_email
updated_user = await self.backend.update_user(new_user)
self.assertEqual(new_user, updated_user)
saved_user = await self.backend.get_user_by_id(
USER_WITH_MULTIPLE_ACCOUNTS_ID
)
self.assertEqual(new_user, saved_user)
async def test_encode_new_token(self):
"""
Dado um objeto User e um Account, retorna um novo
token JWT contendo as informações necessárias
"""
user = User(**USER_WITH_ONE_ACCOUNT_DICT)
account = Account(**ACCOUNT_DEV_DICT)
token = jwt_encode(user, account)
decoded_token = jwt.decode(token, key=SECRET_KEY)
self.assertDictEqual(user.dict(), decoded_token["user"])
self.assertDictEqual(account.dict(), decoded_token["current_account"])
async def test_create_user_all_OK(self):
user = User(name="New User", email="*****@*****.**")
resp = await self.client.post(
f"/users",
headers={
"Authorization": f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
json=user.dict(),
)
self.assertEqual(201, resp.status)
user_data = await resp.json()
expected_result = UserResource(user=user).dict()
expected_result["user"]["id"] = ANY
self.assertEqual(expected_result, user_data)
async def test_create_user_duplicate_email(self):
user_name = "New User"
user_email = USER_WITH_NO_ACCOUNTS_EMAIL
with self.assertRaises(DuplicateEntity):
await self.backend.create_user(
User(name=user_name, email=user_email)
)
async def test_accounts_remove_from_account_user_not_in_account(self):
account = Account(**ACCOUNT_WITH_NO_USERS_DICT)
user = User(**USER_WITH_ONE_ACCOUNT_DICT)
self.assertFalse(await account.user_has_permission(user))
await self.backend.remove_user(user, account)
self.assertFalse(await account.user_has_permission(user))
async def test_create_job_force_owner_constraint_if_already_exist(self):
"""
Mesmo se o Job sendo criado já tiver a constraint `owner:LIKE:...` temos
que substituir por `owner:LIKE:{account.owner}`
"""
user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
account = Account(**ACCOUNT_DEV_DICT)
await _cleanup_chronos()
self.asgard_job.add_constraint("owner:LIKE:other-value")
returned_job = await self.backend.create_job(
self.asgard_job, user, account
)
stored_job = await self.backend.get_job_by_id(
returned_job.id, user, account
)
self.assertCountEqual(
[
"hostname:LIKE:10.0.0.1",
"workload:LIKE:general",
f"owner:LIKE:{account.owner}",
],
stored_job.constraints,
)
async def test_accounts_add_user_success(self):
account = Account(**ACCOUNT_WITH_NO_USERS_DICT)
user = User(**USER_WITH_ONE_ACCOUNT_DICT)
self.assertFalse(await account.user_has_permission(user))
await self.backend.add_user(user, account)
self.assertTrue(await account.user_has_permission(user))
async def test_accounts_remove_user_user_in_account(self):
"""
Quando o body do request é válido, removemos o user da conta
"""
resp = await self.client.delete(
f"/accounts/{ACCOUNT_INFRA_ID}/users/{USER_WITH_MULTIPLE_ACCOUNTS_ID}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
self.assertEqual(200, resp.status)
data = await resp.json()
self.assertEqual({"users": []}, data)
resp_check = await self.client.get(
f"/accounts/{ACCOUNT_INFRA_ID}/users",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
resp_check_data = await resp_check.json()
users_ids = [User(**u).id for u in resp_check_data["users"]]
self.assertNotIn(USER_WITH_NO_ACCOUNTS_ID, users_ids)
async def test_update_job_change_root_fields(self):
await _load_jobs_into_chronos(self.chronos_dev_job_fixture)
user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
account = Account(**ACCOUNT_DEV_DICT)
self.asgard_job._remove_constraint_by_name("owner")
self.asgard_job.remove_namespace(account)
self.asgard_job.cpus = 2
self.asgard_job.mem = 1024
self.asgard_job.description = "Minha description"
self.asgard_job.retries = 4
updated_job = await self.backend.update_job(
self.asgard_job, user, account
)
stored_job = await self.backend.get_job_by_id(
updated_job.id, user, account
)
self.assertEqual(self.asgard_job.cpus, stored_job.cpus)
self.assertEqual(self.asgard_job.mem, stored_job.mem)
self.assertEqual(self.asgard_job.description, stored_job.description)
self.assertEqual(self.asgard_job.retries, stored_job.retries)
async def setUp(self):
await super(DeploymentsTests, self).setUp()
token = jwt_encode(
User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT),
Account(**ACCOUNT_DEV_DICT),
)
self.auth_header = {"Authorization": f"JWT {token.decode('utf-8')}"}
async def test_get_accounts_from_user_user_has_accounts(self):
user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
accounts = await self.backend.get_accounts_from_user(user)
self.assertCountEqual(
[Account(**ACCOUNT_DEV_DICT), Account(**ACCOUNT_INFRA_DICT)],
accounts,
)
async def test_accounts_add_users_to_account_input_OK(self):
"""
Quando o body do request é válido, vinculamos o novo user à conta
"""
resp = await self.client.post(
f"/accounts/{ACCOUNT_WITH_NO_USERS_ID}/users/{USER_WITH_NO_ACCOUNTS_ID}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
self.assertEqual(200, resp.status)
data = await resp.json()
self.assertEqual({"users": []}, data)
resp_check = await self.client.get(
f"/accounts/{ACCOUNT_WITH_NO_USERS_ID}/users",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
resp_check_data = await resp_check.json()
users_ids = [User(**u).id for u in resp_check_data["users"]]
self.assertIn(USER_WITH_NO_ACCOUNTS_ID, users_ids)
async def test_get_apps_stats_with_data(self):
"""
Prepara um ElasticSearch com alguns dados e faz o cálculo
agregado do uso de CPU e RAM
"""
app_stats_datapoints = get_fixture(
f"agents/ead07ffb-5a61-42c9-9386-21b680597e6c-S0/app_stats.json")
app = MesosApp(id="infra/asgard/api")
await self._load_app_stats_into_storage(self.INDEX_NAME, self.utc_now,
app_stats_datapoints)
backend = MarathonAppsBackend()
user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
account = Account(**ACCOUNT_DEV_DICT)
async with Elasticsearch([settings.STATS_API_URL]) as es:
raw = await es.search(index=self.INDEX_NAME)
cpu_pcts = [
hit["_source"]["cpu_pct"] for hit in raw["hits"]["hits"]
]
mem_pcts = [
hit["_source"]["mem_pct"] for hit in raw["hits"]["hits"]
]
self.assertEqual(5, len(cpu_pcts))
self.assertEqual(5, len(mem_pcts))
app_stats = await backend.get_app_stats(app, user, account)
self.assertEqual(
AppStats(cpu_pct="0.25", ram_pct="15.05", cpu_thr_pct="1.00"),
app_stats,
)
async def test_users_endpoint_list_users(self):
resp = await self.client.get(
"/users",
headers={
"Authorization": f"Token {USER_WITH_ONE_ACCOUNT_AUTH_KEY}"
},
)
users_data = await resp.json()
self.assertCountEqual(
UserListResource(users=[
User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT),
User(**USER_WITH_NO_ACCOUNTS_DICT),
User(**USER_WITH_ONE_ACCOUNT_DICT),
]).dict(),
users_data,
)
async def update_user_partial(request: web.Request):
user_id: str = request.match_info["user_id"]
try:
body_data = await request.json()
except JSONDecodeError as e:
return web.json_response(
ErrorResource(errors=[ErrorDetail(msg=str(e))]).dict(),
status=HTTPStatus.UNPROCESSABLE_ENTITY,
)
user = await UsersService.get_user_by_id(int(user_id), UsersBackend())
status_code = HTTPStatus.ACCEPTED if user else HTTPStatus.NOT_FOUND
try:
if user:
body_user = User(**body_data)
user.name = body_user.name if body_user.name else user.name
user.email = body_user.email if body_user.email else user.email
updated_user = await UsersService.update_user(user, UsersBackend())
except DuplicateEntity as de:
return web.json_response(
ErrorResource(errors=[ErrorDetail(msg=str(de))]).dict(),
status=status_code,
)
return web.json_response(UserResource(user=updated_user).dict(),
status=status_code)
async def test_list_jobs_empty_result(self):
user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
account = Account(**ACCOUNT_DEV_DICT)
account.namespace = "namespace-does-not-have-any-jobs"
jobs = await self.backend.list_jobs(user, account)
self.assertCountEqual([], jobs)
async def test_change_account_does_not_exist(self):
jwt_token = jwt_encode(User(**USER_WITH_ONE_ACCOUNT_DICT),
Account(**ACCOUNT_DEV_DICT))
resp = await self.client.get(
f"/accounts/8000/auth",
headers={"Authorization": f"JWT {jwt_token.decode('utf-8')}"},
)
self.assertEqual(403, resp.status)
async def test_delete_user_with_no_accounts(self):
total_users = await self.backend.get_users()
self.assertEqual(3, len(total_users))
user = User(**USER_WITH_NO_ACCOUNTS_DICT)
deleted_user = await self.backend.delete_user(user)
self.assertEqual(deleted_user, user)
remain_users = await self.backend.get_users()
self.assertEqual(2, len(remain_users))
self.assertCountEqual(
[
User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT),
User(**USER_WITH_ONE_ACCOUNT_DICT),
],
remain_users,
)
async def test_update_job_job_does_not_exist(self):
user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
account = Account(**ACCOUNT_DEV_DICT)
await _cleanup_chronos()
with self.assertRaises(NotFoundEntity):
await self.backend.update_job(self.asgard_job, user, account)
async def test_get_alternate_accounts_for_user(self):
user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
current_account = Account(**ACCOUNT_DEV_DICT)
accounts = await UsersBackend().get_alternate_accounts(
user, current_account
)
self.assertEqual(1, len(accounts))
self.assertEqual([Account(**ACCOUNT_INFRA_DICT)], accounts)
async def test_user_trasnform_from_alchemy_object(self):
user = User(**USER_WITH_MULTIPLE_ACCOUNTS_DICT)
_, UserDB = await user.to_alchemy_obj()
async with AsgardDBSession() as s:
user_db = (await s.query(UserDB).filter(
UserDB.id == USER_WITH_MULTIPLE_ACCOUNTS_ID).one())
user = await User.from_alchemy_obj(user_db)
self.assertEqual(user.name, USER_WITH_MULTIPLE_ACCOUNTS_NAME)
self.assertEqual(user.email, USER_WITH_MULTIPLE_ACCOUNTS_EMAIL)