import pytest
import random
from tests.base.authentication_web import AuthenticationWeb


class TestUpdateRole:

    @pytest.mark.asyncio
    async def test_update_role_success(self, authentication_web: AuthenticationWeb):
        """Test updating a role successfully with valid and unique fields."""
        suffix = str(random.randint(10000, 99999))
        # create firstly
        role_data = {
            "role_key": f"update_role_key_{suffix}",
            "role_name": f"Update Role {suffix}",
            "role_description": "desc",
            "role_level": 1
        }
        create_resp = await authentication_web.create_role(role_data)
        role_id = create_resp.json()["id"]
        # update
        update_data = {
            "role_id": role_id,
            "role_key": f"update_role_key_{suffix}_new",
            "role_name": f"Update Role {suffix} New",
            "role_description": "desc new",
            "role_level": 2
        }
        resp = await authentication_web.update_role(role_data=update_data)
        assert resp.status_code == 200
        json = resp.json()
        assert json["role_key"] == update_data["role_key"]
        assert json["role_name"] == update_data["role_name"]
        assert json["role_description"] == update_data["role_description"]
        assert json["role_level"] == update_data["role_level"]

    @pytest.mark.asyncio
    async def test_update_role_fail_not_found(self, authentication_web: AuthenticationWeb):
        """Test updating a role fails when role_id does not exist."""
        suffix = str(random.randint(10000, 99999))
        update_data = {
            "role_id": "000000000000000000000000",  # 不存在的ObjectId
            "role_key": f"notfound_key_{suffix}",
            "role_name": f"NotFound Role {suffix}",
            "role_description": "desc",
            "role_level": 1
        }
        resp = await authentication_web.update_role(role_data=update_data)
        assert resp.status_code == 422 or resp.status_code == 400

    @pytest.mark.asyncio
    async def test_update_role_fail_duplicate_key(self, authentication_web: AuthenticationWeb):
        """Test updating a role fails when role_key is duplicated."""
        suffix = str(random.randint(10000, 99999))
        # create two roles
        role1 = await authentication_web.create_role({
            "role_key": f"dupkey1_{suffix}",
            "role_name": f"dupkey1_{suffix}",
            "role_description": "desc",
            "role_level": 1
        })
        role2 = await authentication_web.create_role({
            "role_key": f"dupkey2_{suffix}",
            "role_name": f"dupkey2_{suffix}",
            "role_description": "desc",
            "role_level": 1
        })
        role2_id = role2.json()["id"]
        # modify role_key
        update_data = {
            "role_id": role2_id,
            "role_key": f"dupkey1_{suffix}",
            "role_name": f"dupkey2_{suffix}_new",
            "role_description": "desc",
            "role_level": 2
        }
        resp = await authentication_web.update_role(role_data=update_data)
        assert resp.status_code == 422 or resp.status_code == 400

    @pytest.mark.asyncio
    async def test_update_role_fail_duplicate_name(self, authentication_web: AuthenticationWeb):
        """Test updating a role fails when role_name is duplicated."""
        suffix = str(random.randint(10000, 99999))
        # create two roles
        role1 = await authentication_web.create_role({
            "role_key": f"dupname1_{suffix}",
            "role_name": f"dupname1_{suffix}",
            "role_description": "desc",
            "role_level": 1
        })
        role2 = await authentication_web.create_role({
            "role_key": f"dupname2_{suffix}",
            "role_name": f"dupname2_{suffix}",
            "role_description": "desc",
            "role_level": 1
        })
        role2_id = role2.json()["id"]
        # modify role name
        update_data = {
            "role_id": role2_id,
            "role_key": f"dupname2_{suffix}_new",
            "role_name": f"dupname1_{suffix}",
            "role_description": "desc",
            "role_level": 2
        }
        resp = await authentication_web.update_role(role_data=update_data)
        assert resp.status_code == 422 or resp.status_code == 400

    @pytest.mark.asyncio
    async def test_update_role_fail_empty_key(self, authentication_web: AuthenticationWeb):
        """Test updating a role fails when role_key is empty."""
        suffix = str(random.randint(10000, 99999))
        role = await authentication_web.create_role({
            "role_key": f"emptykey_{suffix}",
            "role_name": f"emptykey_{suffix}",
            "role_description": "desc",
            "role_level": 1
        })
        role_id = role.json()["id"]
        update_data = {
            "role_id": role_id,
            "role_key": "",
            "role_name": f"emptykey_{suffix}_new",
            "role_description": "desc",
            "role_level": 2
        }
        resp = await authentication_web.update_role(role_data=update_data)
        assert resp.status_code == 422 or resp.status_code == 400

    @pytest.mark.asyncio
    async def test_update_role_fail_empty_name(self, authentication_web: AuthenticationWeb):
        """Test updating a role fails when role_name is empty."""
        suffix = str(random.randint(10000, 99999))
        role = await authentication_web.create_role({
            "role_key": f"emptyname_{suffix}",
            "role_name": f"emptyname_{suffix}",
            "role_description": "desc",
            "role_level": 1
        })
        role_id = role.json()["id"]
        update_data = {
            "role_id": role_id,
            "role_key": f"emptyname_{suffix}_new",
            "role_name": "",
            "role_description": "desc",
            "role_level": 2
        }
        resp = await authentication_web.update_role(role_data=update_data)
        assert resp.status_code == 422 or resp.status_code == 400


if __name__ == '__main__':
    pytest.main([__file__])