Merge pull request #771 from ceydaduzgec/update-trimming-test

Update trimming test

Author: ceydaduzgec

docs/local_linting_guide.md

@@ -0,0 +1,74 @@
+# Local Linting Guide
+
+This guide explains how to run the same linting checks locally that are used in the GitHub Actions CI pipeline.
+
+## Prerequisites
+
+Make sure you have Python installed and create a virtual environment:
+
+```bash
+# Create a virtual environment (if not already created)
+python -m venv venv
+
+# Activate the environment
+source venv/bin/activate  # On Unix/macOS
+# or
+venv\Scripts\activate  # On Windows
+```
+
+## Install Required Tools
+
+Install all the linting tools used in the CI pipeline:
+
+```bash
+# Install Python linting tools
+pip install black isort
+
+# Install Node.js tools (requires Node.js to be installed)
+npm install -g jsonlint
+```
+
+## Linting Commands
+
+### 1. Python Code Formatting (Black)
+
+Check if Python files need formatting:
+```bash
+black --check .
+```
+
+Auto-format Python files:
+```bash
+black .
+```
+
+Check specific files:
+```bash
+black --check tests/test_trimming.py filter.py
+```
+
+### 2. Python Import Sorting (isort)
+
+Check import sorting:
+```bash
+isort --check-only .
+```
+
+Auto-fix import sorting:
+```bash
+isort .
+```
+
+### 3. JSON Validation
+
+Validate JSON files:
+```bash
+jsonlint world_universities_and_domains.json
+```
+
+## GitHub Actions Compatibility
+
+The local commands above mirror exactly what GitHub Actions runs:
+- `black --check .` (same as GitHub Actions)
+- `isort --check-only .` (same as GitHub Actions)  
+- `jsonlint world_universities_and_domains.json` (same as GitHub Actions)

docs/local_testing_guide.md

@@ -0,0 +1,60 @@
+# Local Testing Guide
+
+To run the project tests:
+
+1. **Set up a virtual environment** (recommended)
+
+```bash
+# Create a virtual environment (if not already created)
+python -m venv venv
+
+# Activate the environment
+source venv/bin/activate  # On Unix/macOS
+# or
+venv\Scripts\activate  # On Windows
+```
+
+2. **Install test dependencies**
+
+```bash
+pip install -r tests/requirements.txt
+```
+
+3. **Run tests using unittest**
+
+   ```bash
+   # From the tests directory
+   python -m unittest discover
+
+   # Or from the project root
+   python -m unittest discover tests
+   ```
+
+## Test Coverage
+
+- **Structure validation**: Validates JSON schema and field types
+- **Domain validation**: Checks domain format using validators library
+- **URL validation**: Validates web page URLs
+- **Field trimming**: Ensures no leading/trailing whitespace
+- **Country code validation**: Verifies 2-character alpha codes
+
+## Adding Custom Tests
+
+Create new test files in `tests/` directory following the existing pattern:
+
+```python
+import json
+import unittest
+import os
+
+class CustomTests(unittest.TestCase):
+    def setUp(self):
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        json_path = os.path.join(os.path.dirname(script_dir), "world_universities_and_domains.json")
+        with open(json_path, encoding="utf-8") as json_file:
+            self.data = json.load(json_file)
+    
+    def test_custom_validation(self):
+        # Your test logic here
+        pass
+```

tests/test_trimming.py

@@ -20,60 +20,78 @@ def setUp(self):
 
     def test_trimmed_fields(self):
         """Test that all string fields in each university entry are properly trimmed"""
-        for university in self.valid_json:
+        errors = []
+
+        for i, university in enumerate(self.valid_json):
             # Check university name
             if isinstance(university["name"], str):
-                self.assertEqual(
-                    university["name"],
-                    university["name"].strip(),
-                    msg=f"University Name contains leading/trailing whitespace: '{university['name']}'",
-                )
+                original_name = university["name"]
+                trimmed_name = original_name.strip()
+                if original_name != trimmed_name:
+                    errors.append(
+                        f"Entry {i}: University Name contains leading/trailing whitespace: '{original_name}' -> should be '{trimmed_name}'"
+                    )
 
             # Check domains
             if university["domains"] is not None:
-                for domain in university["domains"]:
+                for j, domain in enumerate(university["domains"]):
                     if isinstance(domain, str):
-                        self.assertEqual(
-                            domain,
-                            domain.strip(),
-                            msg=f"Domain contains leading/trailing whitespace: '{domain}'",
-                        )
+                        original_domain = domain
+                        trimmed_domain = original_domain.strip()
+                        if original_domain != trimmed_domain:
+                            errors.append(
+                                f"Entry {i}: Domain {j} contains leading/trailing whitespace: '{original_domain}' -> should be '{trimmed_domain}'"
+                            )
 
             # Check web_pages
             if university["web_pages"] is not None:
-                for web_page in university["web_pages"]:
+                for j, web_page in enumerate(university["web_pages"]):
                     if isinstance(web_page, str):
-                        self.assertEqual(
-                            web_page,
-                            web_page.strip(),
-                            msg=f"Web page contains leading/trailing whitespace: '{web_page}'",
-                        )
+                        original_web_page = web_page
+                        trimmed_web_page = original_web_page.strip()
+                        if original_web_page != trimmed_web_page:
+                            errors.append(
+                                f"Entry {i}: Web page {j} contains leading/trailing whitespace: '{original_web_page}' -> should be '{trimmed_web_page}'"
+                            )
 
             # Check country
             if isinstance(university["country"], str):
-                self.assertEqual(
-                    university["country"],
-                    university["country"].strip(),
-                    msg=f"Country contains leading/trailing whitespace: '{university['country']}'",
-                )
+                original_country = university["country"]
+                trimmed_country = original_country.strip()
+                if original_country != trimmed_country:
+                    errors.append(
+                        f"Entry {i}: Country contains leading/trailing whitespace: '{original_country}' -> should be '{trimmed_country}'"
+                    )
 
             # Check alpha_two_code
             if isinstance(university["alpha_two_code"], str):
-                self.assertEqual(
-                    university["alpha_two_code"],
-                    university["alpha_two_code"].strip(),
-                    msg=f"Alpha two code contains leading/trailing whitespace: '{university['alpha_two_code']}'",
-                )
+                original_alpha = university["alpha_two_code"]
+                trimmed_alpha = original_alpha.strip()
+                if original_alpha != trimmed_alpha:
+                    errors.append(
+                        f"Entry {i}: Alpha two code contains leading/trailing whitespace: '{original_alpha}' -> should be '{trimmed_alpha}'"
+                    )
 
             # Check state-province
             if isinstance(university["state-province"], str):
-                self.assertEqual(
-                    university["state-province"],
-                    university["state-province"].strip(),
-                    msg=f"State/Province contains leading/trailing whitespace: '{university['state-province']}'",
-                )
+                original_state = university["state-province"]
+                trimmed_state = original_state.strip()
+                if original_state != trimmed_state:
+                    errors.append(
+                        f"Entry {i}: State/Province contains leading/trailing whitespace: '{original_state}' -> should be '{trimmed_state}'"
+                    )
+
+        # If there are any errors, fail the test with all error messages
+        if errors:
+            error_message = (
+                f"Found {len(errors)} fields with whitespace issues:\n"
+                + "\n".join(errors[:10])
+            )  # Show first 10 errors
+            if len(errors) > 10:
+                error_message += f"\n... and {len(errors) - 10} more errors"
+            self.fail(error_message)
 
 
 # Run tests locally
-# if __name__ == "__main__":
-#    unittest.main()
+if __name__ == "__main__":
+    unittest.main()

world_universities_and_domains.json

@@ -37568,7 +37568,7 @@
     "country": "Ireland"
   },
   {
-    "web_pages": ["https://www.tus.ie/"],
+    "web_pages": ["https://tus.ie/"],
     "name": "Technological University of the Shannon",
     "alpha_two_code": "IE",
     "state-province": "Limerick",
@@ -70215,7 +70215,7 @@
     "web_pages": ["https://www.minerva.edu/"],
     "name": "Minerva University",
     "alpha_two_code": "US",
-    "state-province": "CA",
+    "state-province": "California",
     "domains": ["minerva.edu"],
     "country": "United States"
   },