tests, sessionID checking

Author: Coderbeep

leetcode/configuration.py

@@ -31,17 +31,40 @@ def execute(self, args):
             if getattr(args, 'config_key') and getattr(args, 'config_value'):
                 self.dump_key(args.config_key, args.config_value)
                 print('Configuration updated successfully.')
-                
-def check_session():
-    with open(CONFIG_PATH, 'r') as yaml_file:
+              
+def check_session_response(session_id: str) -> bool:
+    QUERY = """ query
+            {
+                user {
+                username
+                isCurrentUserPremium
+                }
+            }
+            """
+    response = requests.post(url="https://leetcode.com/graphql",
+                                json={'query': QUERY},
+                                cookies={'LEETCODE_SESSION': session_id})
+    if response.json()['data']['user']:
+        return True
+    else:  
+        return False
+
+def update_session_id(session_id: str, path = CONFIG_PATH):
+    with open(path, 'r') as yaml_file:
+        data = yaml.safe_load(yaml_file)
+    
+    data['user_data']['session_id'] = session_id
+    with open(path, 'w') as yaml_file:
+        yaml.dump(data, yaml_file, default_flow_style=False)
+
+def check_session_validity(path = CONFIG_PATH) -> bool:
+    with open(path, 'r') as yaml_file:
         data = yaml.safe_load(yaml_file)
 
     SESSION_ID = data['user_data']['session_id']
-    if SESSION_ID == '': # or the id is not valid!
-        SESSION_ID = input("Please provide the SESSION_ID: ")
-        data['user_data']['session_id'] = SESSION_ID
-        with open(CONFIG_PATH, 'w') as yaml_file:
-            yaml.dump(data, yaml_file, default_flow_style=False)
+    while not check_session_response(SESSION_ID):
+        SESSION_ID = input("Please provide the proper SESSION_ID: ")
+    update_session_id(SESSION_ID)
     return True
 
 """ The main configuration class for the connection to GraphQL API.
@@ -68,7 +91,6 @@ def __init__(self, session_id: str = ''):
                                'Referer': self.host}
         self._cookies: dict = {'csrftoken': self._csrf_cookie,
                                'LEETCODE_SESSION': self.session_id}  
-        
         if not Configuration.session_checked:
             self.check_session_validity() 
 

leetcode/main.py

@@ -1,7 +1,8 @@
 import argparse
 from models import *
-from leetcode.configuration import check_session, UserConfig
+from leetcode.configuration import check_session_validity, UserConfig
 
+# TODO: add --version
 # TODO: add a command to open the question in editor
 # TODO: submit the solution from the terminal
 # TODO: add a command to show the solution in the terminal
@@ -63,5 +64,5 @@ def main():
 
 
 if __name__ == '__main__':
-    if check_session():
+    if check_session_validity():
         main()

tests/test_check_session.py

@@ -0,0 +1,81 @@
+import pytest
+from leetcode.configuration import check_session_response, check_session_validity, update_session_id
+import os
+import tempfile
+import yaml
+import requests_mock
+
+@pytest.fixture
+def temp_config_file():
+    temp_dir = tempfile.mkdtemp()
+    temp_file_path = os.path.join(temp_dir, 'temp_config.yaml')
+
+    yaml_data = {
+        'user_data': {
+            'csrv_token': 'example_token',
+            'session_id': 'example_session_id',
+            'username': 'coderbeep'
+        }
+    }
+
+    with open(temp_file_path, 'w') as temp_file:
+        yaml.dump(yaml_data, temp_file, default_flow_style=False)
+    print(temp_file_path)
+    return temp_file_path  # Provide the temporary file path to the tests
+
+@pytest.fixture
+def mock_requests():
+    with requests_mock.Mocker() as m:
+        yield m
+        
+def test_valid_session(mock_requests):
+    mock_requests.post('https://leetcode.com/graphql', json={'data': {'user': {'username': None, 'isCurrentUserPremium': False}}})
+
+    session_id = 'valid_session_id'
+    result = check_session_response(session_id)
+    assert result is True
+
+def test_invalid_session(mock_requests):
+    mock_requests.post('https://leetcode.com/graphql', json={'data': {'user': None}})
+
+    session_id = 'invalid_session_id'
+    result = check_session_response(session_id)
+    assert result is False
+    
+def test_update_session_id(temp_config_file):
+    update_session_id('new_session_id', temp_config_file)
+    with open(temp_config_file, 'r') as yaml_file:
+        data = yaml.safe_load(yaml_file)
+    assert data['user_data']['session_id'] == 'new_session_id'
+
+def test_check_session_validity(temp_config_file, monkeypatch):
+    monkeypatch.setattr('leetcode.configuration.check_session_response', lambda x: True)
+    monkeypatch.setattr('builtins.input', lambda x: 'new_session_id')
+    
+    monkeypatch.setattr('leetcode.configuration.update_session_id', lambda x: None)
+    assert check_session_validity(temp_config_file) is True
+
+def test_check_session_validity_with_invalid_session_id(temp_config_file, monkeypatch):
+    # Mocking the check_session_response function to always return False
+    counter = 0
+    def mock_check_session_response(session_id):
+        nonlocal counter
+        if counter < 3:
+            counter += 1
+            return False
+        else:
+            return True
+    monkeypatch.setattr('leetcode.configuration.check_session_response', mock_check_session_response)
+
+    # Mocking the input function to return a specific value
+    monkeypatch.setattr('builtins.input', lambda x: 'new_session_id')
+
+    # Mocking the update_session_id function to just pass
+    monkeypatch.setattr('leetcode.configuration.update_session_id',  lambda x: None)
+
+    # Import and call the check_session_validity function
+    assert check_session_validity(temp_config_file)
+# cases: 
+# 1. session_id is empty
+# 2. session_id is valid
+# 3. session_id is invalid

tests/test_user_config.py

@@ -1,11 +1,15 @@
-import tempfile
+import argparse
 import os
-import yaml
+import tempfile
+
 import pytest
-import argparse
-from leetcode.configuration import UserConfig  # Replace 'your_module' with the actual module where UserConfig is defined
+import yaml
+
+from leetcode.configuration import \
+    UserConfig 
 
-# Define a fixture to create a temporary configuration file
+
+# fixture for temporary config file
 @pytest.fixture
 def temp_config_file():
     temp_dir = tempfile.mkdtemp()
@@ -24,35 +28,34 @@ def temp_config_file():
 
     return temp_file_path  # Provide the temporary file path to the tests
 
+# fixture for UserConfig object with temporary config file
 @pytest.fixture
-def user_config_with_temp_file(temp_config_file):
+def user_config_with_temp_file(temp_config_file: str):
     return UserConfig(config_path=temp_config_file)
 
 # Test UserConfig initialization
-def test_userconfig_init(temp_config_file):
+def test_userconfig_init(temp_config_file: str):
     user_config = UserConfig(config_path=temp_config_file)
     assert user_config.path == temp_config_file
     assert user_config.data is not None
 
 # Test UserConfig get method
-def test_userconfig_get(temp_config_file):
+def test_userconfig_get(temp_config_file: str):
     user_config = UserConfig(config_path=temp_config_file)
     assert user_config.get('csrv_token') == 'example_token'
 
 # Test UserConfig dump_key method
-def test_userconfig_dump_key(temp_config_file):
+def test_userconfig_dump_key(temp_config_file: str):
     user_config = UserConfig(config_path=temp_config_file)
 
-    # Dump a key-value pair and check if it's updated in the config file
     user_config.dump_key('new_key', 'new_value')
 
-    # Read the config file to check if the value is updated
     with open(temp_config_file, 'r') as yaml_file:
         data = yaml.safe_load(yaml_file)
     assert data['user_data']['new_key'] == 'new_value'
 
 # Test UserConfig execute method with valid args
-def test_userconfig_execute_valid_args(user_config_with_temp_file, capsys):
+def test_userconfig_execute_valid_args(user_config_with_temp_file: UserConfig, capsys: pytest.CaptureFixture[str]):
     args = argparse.Namespace(config_key='csrv_token', config_value='new_token')
     user_config_with_temp_file.execute(args)
 
@@ -62,10 +65,12 @@ def test_userconfig_execute_valid_args(user_config_with_temp_file, capsys):
     assert "Configuration updated successfully." in captured.out
 
 # Test UserConfig execute method with invalid config_key
-def test_userconfig_execute_invalid_key(user_config_with_temp_file, capsys):
+def test_userconfig_execute_invalid_key(user_config_with_temp_file: UserConfig, capsys: pytest.CaptureFixture[str]):
     args = argparse.Namespace(config_key='invalid_key', config_value='new_value')
     user_config_with_temp_file.execute(args)
 
     # Check if an error message is printed for an invalid key
     captured = capsys.readouterr()
     assert "Invalid key: invalid_key" in captured.out
+    
+# argparse module handles the case when either of the arguments is missing