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)