Update testcases

Author: wu-clan

tests/clients/test_feishu.py

@@ -19,15 +19,11 @@
 
 @pytest.fixture
 def feishu_client():
-    """Create FeiShu OAuth2 client instance for testing."""
     return FeiShuOAuth20(client_id=TEST_CLIENT_ID, client_secret=TEST_CLIENT_SECRET)
 
 
 class TestFeiShuOAuth20:
-    """Test FeiShu OAuth2 client functionality."""
-
-    def test_feishu_client_initialization(self, feishu_client):
-        """Test FeiShu client initialization with correct parameters."""
+    def test_client_initialization(self, feishu_client):
         assert feishu_client.client_id == TEST_CLIENT_ID
         assert feishu_client.client_secret == TEST_CLIENT_SECRET
         assert feishu_client.authorize_endpoint == 'https://passport.feishu.cn/suite/passport/oauth/authorize'
@@ -39,130 +35,97 @@ def test_feishu_client_initialization(self, feishu_client):
             'contact:user.email:readonly',
         ]
 
-    def test_feishu_client_initialization_with_custom_credentials(self):
-        """Test FeiShu client initialization with custom credentials."""
-        client = FeiShuOAuth20(client_id=TEST_CLIENT_ID, client_secret=TEST_CLIENT_SECRET)
-        assert client.client_id == TEST_CLIENT_ID
-        assert client.client_secret == TEST_CLIENT_SECRET
-
-    def test_feishu_client_inheritance(self, feishu_client):
-        """Test that FeiShu client properly inherits from OAuth20Base."""
+    def test_client_inheritance(self, feishu_client):
         assert isinstance(feishu_client, OAuth20Base)
 
-    def test_feishu_client_scopes_are_lists(self, feishu_client):
-        """Test that default scopes are properly configured as lists."""
+    def test_client_scopes_are_lists(self, feishu_client):
         assert isinstance(feishu_client.default_scopes, list)
         assert len(feishu_client.default_scopes) == 3
         assert all(isinstance(scope, str) for scope in feishu_client.default_scopes)
 
-    def test_feishu_client_endpoint_urls(self):
-        """Test that FeiShu client uses correct endpoint URLs."""
-        client = FeiShuOAuth20(TEST_CLIENT_ID, TEST_CLIENT_SECRET)
-
-        # Test that endpoints are correctly set without hardcoding them in tests
-        assert client.authorize_endpoint.endswith('/suite/passport/oauth/authorize')
-        assert client.access_token_endpoint.endswith('/suite/passport/oauth/token')
-        assert client.refresh_token_endpoint.endswith('/suite/passport/oauth/authorize')
-
-        # Test that all endpoints use the correct domain
-        for endpoint in [client.authorize_endpoint, client.access_token_endpoint, client.refresh_token_endpoint]:
+    def test_client_endpoint_urls(self, feishu_client):
+        assert feishu_client.authorize_endpoint.endswith('/suite/passport/oauth/authorize')
+        assert feishu_client.access_token_endpoint.endswith('/suite/passport/oauth/token')
+        assert feishu_client.refresh_token_endpoint.endswith('/suite/passport/oauth/authorize')
+        for endpoint in [
+            feishu_client.authorize_endpoint,
+            feishu_client.access_token_endpoint,
+            feishu_client.refresh_token_endpoint,
+        ]:
             assert 'passport.feishu.cn' in endpoint
 
-    def test_feishu_client_multiple_instances(self):
-        """Test that multiple FeiShu client instances work independently."""
+    def test_client_multiple_instances(self):
         client1 = FeiShuOAuth20('client1', 'secret1')
         client2 = FeiShuOAuth20('client2', 'secret2')
-
         assert client1.client_id != client2.client_id
         assert client1.client_secret != client2.client_secret
         assert client1.authorize_endpoint == client2.authorize_endpoint
-        assert client1.access_token_endpoint == client2.access_token_endpoint
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_success(self, feishu_client):
-        """Test successful user info retrieval from FeiShu API."""
         mock_user_data = create_mock_user_data('feishu')
         mock_user_info_response(respx, FEISHU_USER_INFO_URL, mock_user_data)
-
         result = await feishu_client.get_userinfo(TEST_ACCESS_TOKEN)
         assert result == mock_user_data
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_with_different_access_token(self, feishu_client):
-        """Test user info retrieval with different access tokens."""
         mock_user_data = create_mock_user_data('feishu', user_id='user_789', name='Another User')
         mock_user_info_response(respx, FEISHU_USER_INFO_URL, mock_user_data)
-
         result = await feishu_client.get_userinfo('different_token')
         assert result == mock_user_data
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_empty_response(self, feishu_client):
-        """Test handling of empty user info response."""
         mock_user_info_response(respx, FEISHU_USER_INFO_URL, {})
-
         result = await feishu_client.get_userinfo(TEST_ACCESS_TOKEN)
         assert result == {}
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_partial_data(self, feishu_client):
-        """Test handling of partial user info response."""
         partial_data = {'user_id': 'test_user', 'name': 'Test User'}
         mock_user_info_response(respx, FEISHU_USER_INFO_URL, partial_data)
-
         result = await feishu_client.get_userinfo(TEST_ACCESS_TOKEN)
         assert result == partial_data
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_authorization_header(self, feishu_client):
-        """Test that authorization header is correctly formatted."""
         mock_user_data = {'user_id': 'test_user'}
         route = mock_user_info_response(respx, FEISHU_USER_INFO_URL, mock_user_data)
-
         await feishu_client.get_userinfo(TEST_ACCESS_TOKEN)
-
-        # Verify the request was made with correct authorization header
         assert route.called
         request = route.calls[0].request
         assert request.headers['authorization'] == f'Bearer {TEST_ACCESS_TOKEN}'
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_http_error_401(self, feishu_client):
-        """Test handling of 401 HTTP error when getting user info."""
         respx.get(FEISHU_USER_INFO_URL).mock(return_value=httpx.Response(401, text='Unauthorized'))
-
         with pytest.raises(HTTPXOAuth20Error):
             await feishu_client.get_userinfo(INVALID_TOKEN)
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_http_error_403(self, feishu_client):
-        """Test handling of 403 HTTP error when getting user info."""
         respx.get(FEISHU_USER_INFO_URL).mock(return_value=httpx.Response(403, text='Forbidden'))
-
         with pytest.raises(HTTPXOAuth20Error):
             await feishu_client.get_userinfo(TEST_ACCESS_TOKEN)
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_http_error_500(self, feishu_client):
-        """Test handling of 500 HTTP error when getting user info."""
         respx.get(FEISHU_USER_INFO_URL).mock(return_value=httpx.Response(500, text='Internal Server Error'))
-
         with pytest.raises(HTTPXOAuth20Error):
             await feishu_client.get_userinfo(TEST_ACCESS_TOKEN)
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_invalid_json(self, feishu_client):
-        """Test handling of invalid JSON response."""
         respx.get(FEISHU_USER_INFO_URL).mock(return_value=httpx.Response(200, text='invalid json'))
-
         with pytest.raises(GetUserInfoError):
             await feishu_client.get_userinfo(TEST_ACCESS_TOKEN)

tests/clients/test_gitee.py

@@ -19,108 +19,80 @@
 
 @pytest.fixture
 def gitee_client():
-    """Create Gitee OAuth2 client instance for testing."""
     return GiteeOAuth20(client_id=TEST_CLIENT_ID, client_secret=TEST_CLIENT_SECRET)
 
 
 class TestGiteeOAuth20:
-    """Test Gitee OAuth2 client functionality."""
-
-    def test_gitee_client_initialization(self, gitee_client):
-        """Test Gitee client initialization with correct parameters."""
+    def test_client_initialization(self, gitee_client):
         assert gitee_client.client_id == TEST_CLIENT_ID
         assert gitee_client.client_secret == TEST_CLIENT_SECRET
         assert gitee_client.authorize_endpoint == 'https://gitee.com/oauth/authorize'
         assert gitee_client.access_token_endpoint == 'https://gitee.com/oauth/token'
         assert gitee_client.refresh_token_endpoint == 'https://gitee.com/oauth/token'
         assert gitee_client.default_scopes == ['user_info']
 
-    def test_gitee_client_initialization_with_custom_credentials(self):
-        """Test Gitee client initialization with custom credentials."""
-        client = GiteeOAuth20(client_id=TEST_CLIENT_ID, client_secret=TEST_CLIENT_SECRET)
-        assert client.client_id == TEST_CLIENT_ID
-        assert client.client_secret == TEST_CLIENT_SECRET
-
-    def test_gitee_client_inheritance(self, gitee_client):
-        """Test that Gitee client properly inherits from OAuth20Base."""
+    def test_client_inheritance(self, gitee_client):
         assert isinstance(gitee_client, OAuth20Base)
 
-    def test_gitee_client_scopes_are_lists(self, gitee_client):
-        """Test that default scopes are properly configured as lists."""
+    def test_client_scopes_are_lists(self, gitee_client):
         assert isinstance(gitee_client.default_scopes, list)
         assert len(gitee_client.default_scopes) == 1
         assert all(isinstance(scope, str) for scope in gitee_client.default_scopes)
 
-    def test_gitee_client_endpoint_urls(self):
-        """Test that Gitee client uses correct endpoint URLs."""
-        client = GiteeOAuth20(TEST_CLIENT_ID, TEST_CLIENT_SECRET)
-
-        # Test that endpoints are correctly set without hardcoding them in tests
-        assert client.authorize_endpoint.endswith('/oauth/authorize')
-        assert client.access_token_endpoint.endswith('/oauth/token')
-        assert client.refresh_token_endpoint.endswith('/oauth/token')
-
-        # Test that all endpoints use the correct domain
-        for endpoint in [client.authorize_endpoint, client.access_token_endpoint, client.refresh_token_endpoint]:
+    def test_client_endpoint_urls(self, gitee_client):
+        assert gitee_client.authorize_endpoint.endswith('/oauth/authorize')
+        assert gitee_client.access_token_endpoint.endswith('/oauth/token')
+        assert gitee_client.refresh_token_endpoint.endswith('/oauth/token')
+        for endpoint in [
+            gitee_client.authorize_endpoint,
+            gitee_client.access_token_endpoint,
+            gitee_client.refresh_token_endpoint,
+        ]:
             assert 'gitee.com' in endpoint
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_success(self, gitee_client):
-        """Test successful user info retrieval from Gitee API."""
         mock_user_data = create_mock_user_data('gitee')
         mock_user_info_response(respx, GITEE_USER_INFO_URL, mock_user_data)
-
         result = await gitee_client.get_userinfo(TEST_ACCESS_TOKEN)
         assert result == mock_user_data
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_authorization_header(self, gitee_client):
-        """Test that authorization header is correctly formatted."""
         mock_user_data = {'id': 'test_user'}
         route = mock_user_info_response(respx, GITEE_USER_INFO_URL, mock_user_data)
-
         await gitee_client.get_userinfo(TEST_ACCESS_TOKEN)
-
-        # Verify the request was made with correct authorization header
         assert route.called
         request = route.calls[0].request
         assert request.headers['authorization'] == f'Bearer {TEST_ACCESS_TOKEN}'
 
-    @pytest.mark.asyncio
-    @respx.mock
-    async def test_get_userinfo_http_error(self, gitee_client):
-        """Test handling of HTTP errors when getting user info."""
-        respx.get(GITEE_USER_INFO_URL).mock(return_value=httpx.Response(401, text='Unauthorized'))
-
-        with pytest.raises(HTTPXOAuth20Error):
-            await gitee_client.get_userinfo(INVALID_TOKEN)
-
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_empty_response(self, gitee_client):
-        """Test handling of empty user info response."""
         mock_user_info_response(respx, GITEE_USER_INFO_URL, {})
-
         result = await gitee_client.get_userinfo(TEST_ACCESS_TOKEN)
         assert result == {}
 
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_partial_data(self, gitee_client):
-        """Test handling of partial user info response."""
         partial_data = {'id': 123456, 'login': 'testuser'}
         mock_user_info_response(respx, GITEE_USER_INFO_URL, partial_data)
-
         result = await gitee_client.get_userinfo(TEST_ACCESS_TOKEN)
         assert result == partial_data
 
+    @pytest.mark.asyncio
+    @respx.mock
+    async def test_get_userinfo_http_error(self, gitee_client):
+        respx.get(GITEE_USER_INFO_URL).mock(return_value=httpx.Response(401, text='Unauthorized'))
+        with pytest.raises(HTTPXOAuth20Error):
+            await gitee_client.get_userinfo(INVALID_TOKEN)
+
     @pytest.mark.asyncio
     @respx.mock
     async def test_get_userinfo_invalid_json(self, gitee_client):
-        """Test handling of invalid JSON response."""
         respx.get(GITEE_USER_INFO_URL).mock(return_value=httpx.Response(200, text='invalid json'))
-
         with pytest.raises(GetUserInfoError):
             await gitee_client.get_userinfo(TEST_ACCESS_TOKEN)