Files
2026-09-29 16:01:16 +02:00

1408 lines
44 KiB
Python

"""Tests for the JSON linter module (json_lint).
Follows TDD principles - tests are written first before implementation.
"""
from __future__ import annotations
import json
import pathlib
import subprocess
import sys
import tempfile
from io import StringIO
import pytest
from fiona.customlinter.base import BaseLinter, LinterError, LintViolation
from fiona.customlinter.jsonlint import JsonLinter, main
# AI/LLM: the suite is not tied to a Linux checkout path.
REPO_ROOT = pathlib.Path(__file__).resolve().parents[1]
def _run_jsonlint_cli(argv: list[str]) -> subprocess.CompletedProcess[str]:
"""Run jsonlint.main in a subprocess with a safely quoted argv.
Generated by AI/LLM: 2026-09-29 - embedding a Windows path in a
Python -c string treats backslashes as unicode escapes.
Args:
argv: Arguments assigned to sys.argv in the child.
Returns:
The completed subprocess.
"""
script = (
"from fiona.customlinter.jsonlint import main; import sys; "
f"sys.argv = {argv!r}; main()"
)
return subprocess.run(
[sys.executable, "-c", script],
capture_output=True,
text=True,
check=False,
)
def test_json_lint_module_exists():
"""Test that the jsonlint module can be imported."""
assert JsonLinter is not None
def test_json_linter_class_exists():
"""Test that the JsonLinter class exists and is a subclass of BaseLinter."""
assert issubclass(JsonLinter, BaseLinter)
def test_json_linter_file_extensions():
"""Test that JsonLinter has the correct file extensions."""
assert hasattr(JsonLinter, 'file_extensions')
assert '.json' in JsonLinter.file_extensions
def test_json_linter_settings_key_path():
"""Test that JsonLinter has the correct settings key path."""
assert hasattr(JsonLinter, 'settings_key_path')
assert JsonLinter.settings_key_path == ['json']
def test_json_linter_linter_name():
"""Test that JsonLinter has the correct linter name."""
assert hasattr(JsonLinter, 'linter_name')
assert JsonLinter.linter_name == 'JSONLint'
def test_json_linter_violation_codes():
"""Test that JsonLinter has violation codes defined."""
assert hasattr(JsonLinter, 'VIOLATION_CODES')
assert isinstance(JsonLinter.VIOLATION_CODES, dict)
# Check that expected violation codes are present
assert 'JSN001' in JsonLinter.VIOLATION_CODES
assert 'JSN002' in JsonLinter.VIOLATION_CODES
assert 'JSN003' in JsonLinter.VIOLATION_CODES
assert 'JSN004' in JsonLinter.VIOLATION_CODES
def test_lint_file_valid_json():
"""Test linting a valid JSON file with no violations."""
linter = JsonLinter()
# Create a temporary valid JSON file
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
json.dump({"name": "test", "version": "1.0.0"}, f)
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
assert isinstance(violations, list)
# Valid JSON should have no violations
assert len(violations) == 0
finally:
pathlib.Path(temp_file).unlink()
def test_lint_file_invalid_json():
"""Test linting an invalid JSON file returns syntax error violation."""
linter = JsonLinter()
# Create a temporary invalid JSON file
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"name": "test", "version": "1.0.0"') # Missing closing brace
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
assert isinstance(violations, list)
# Invalid JSON should have at least one violation
assert len(violations) > 0
# Check that at least one violation has the syntax error code
codes = [v.code for v in violations]
assert 'JSN001' in codes
finally:
pathlib.Path(temp_file).unlink()
def test_lint_file_trailing_comma():
"""Test linting a JSON file with trailing commas."""
linter = JsonLinter()
# Create a temporary JSON file with trailing comma (invalid in strict JSON)
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"name": "test", "version": "1.0.0",}') # Trailing comma
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
assert isinstance(violations, list)
# Should have at least one violation
assert len(violations) > 0
finally:
pathlib.Path(temp_file).unlink()
def test_lint_file_duplicate_keys():
"""Test linting a JSON file with duplicate keys."""
linter = JsonLinter()
# Create a temporary JSON file with duplicate keys
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"name": "test", "name": "duplicate", "version": "1.0.0"}')
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
assert isinstance(violations, list)
# Should detect duplicate keys if check_duplicate_keys is enabled
assert len(violations) >= 0 # May or may not have violations depending on settings
finally:
pathlib.Path(temp_file).unlink()
def test_lint_file_indentation():
"""Test linting a JSON file with incorrect indentation."""
linter = JsonLinter()
# Create a temporary JSON file with mixed indentation
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"name": "test",\n "nested": {\n "key": "value"\n }\n}') # Mixed tabs and spaces
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
assert isinstance(violations, list)
# Valid JSON syntax, so no syntax errors
# Indentation violations depend on settings
finally:
pathlib.Path(temp_file).unlink()
def test_lint_directory():
"""Test linting a directory of JSON files."""
linter = JsonLinter()
# Create a temporary directory with multiple JSON files
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create valid JSON file
valid_file = temp_path / 'valid.json'
with open(valid_file, 'w') as f:
json.dump({"name": "valid"}, f)
# Create invalid JSON file
invalid_file = temp_path / 'invalid.json'
with open(invalid_file, 'w') as f:
f.write('{"name": "invalid"') # Missing closing brace
violations = linter.lint_directory(temp_path)
assert isinstance(violations, list)
# Should have at least one violation from the invalid file
assert len(violations) > 0
def test_lint_directory_no_json_files():
"""Test linting a directory with no JSON files."""
linter = JsonLinter()
# Create a temporary directory with no JSON files
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create a non-JSON file
txt_file = temp_path / 'readme.txt'
with open(txt_file, 'w') as f:
f.write('This is a text file')
violations = linter.lint_directory(temp_path)
assert isinstance(violations, list)
# Should have no violations since there are no JSON files
assert len(violations) == 0
def test_violation_is_lint_violation():
"""Test that violations are LintViolation instances."""
linter = JsonLinter()
# Create a temporary invalid JSON file
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"invalid": }') # Invalid JSON
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
if violations:
for violation in violations:
assert isinstance(violation, LintViolation)
assert hasattr(violation, 'filepath')
assert hasattr(violation, 'line')
assert hasattr(violation, 'column')
assert hasattr(violation, 'code')
assert hasattr(violation, 'message')
assert hasattr(violation, 'rule_id')
assert hasattr(violation, 'severity')
finally:
pathlib.Path(temp_file).unlink()
def test_compress_violations():
"""Test compressing violations into the shared format."""
linter = JsonLinter()
# Create a temporary invalid JSON file
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"invalid": }')
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
if violations:
compressed = linter.compress_violations(violations, temp_file)
assert isinstance(compressed, dict)
assert 'files' in compressed
assert 'descriptions' in compressed
assert 'meta' in compressed
assert isinstance(compressed['files'], dict)
assert isinstance(compressed['descriptions'], dict)
assert isinstance(compressed['meta'], dict)
finally:
pathlib.Path(temp_file).unlink()
def test_format_violations():
"""Test formatting violations for display."""
linter = JsonLinter()
# Create a temporary invalid JSON file
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"invalid": }')
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
if violations:
compressed = linter.compress_violations(violations, temp_file)
formatted = linter.format_compressed_violations(compressed)
assert isinstance(formatted, str)
# Should contain linter name
assert 'JSONLint' in formatted
# Should contain sections
assert 'DEFINITIONS' in formatted or 'Violations' in formatted
finally:
pathlib.Path(temp_file).unlink()
def test_format_violations_empty():
"""Test formatting empty violations."""
linter = JsonLinter()
# Create a temporary valid JSON file
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
json.dump({"name": "test"}, f)
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
compressed = linter.compress_violations(violations, temp_file)
formatted = linter.format_compressed_violations(compressed)
assert isinstance(formatted, str)
# Should indicate no violations
assert 'No violations' in formatted or 'violations' in formatted.lower()
finally:
pathlib.Path(temp_file).unlink()
def test_fix_file_valid_json():
"""Test fixing a valid JSON file (should return empty list)."""
linter = JsonLinter()
# Create a temporary valid JSON file
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
json.dump({"name": "test", "version": "1.0.0"}, f, indent=2)
temp_file = f.name
try:
# Read original content
with open(temp_file, 'r') as f:
original_content = f.read()
# Try to fix (should return list of fixed files)
fixed_files = linter.fix_file(pathlib.Path(temp_file))
assert isinstance(fixed_files, list)
# Content should be valid JSON (may have trailing newline added for consistency)
with open(temp_file, 'r') as f:
new_content = f.read()
# Parse both to ensure they're equivalent
original_data = json.loads(original_content)
new_data = json.loads(new_content)
assert original_data == new_data
finally:
pathlib.Path(temp_file).unlink()
def test_fix_file_with_settings():
"""Test fixing a JSON file with specific settings."""
# Create settings file
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
settings = {
"json": {
"indent": "space",
"indent_len": 4,
"trailing_commas": False,
"require_key_order": False,
"check_duplicate_keys": True
}
}
json.dump(settings, f)
settings_file = f.name
try:
linter = JsonLinter(settings_file=pathlib.Path(settings_file))
assert linter is not None
finally:
pathlib.Path(settings_file).unlink()
def test_main_function():
"""Test the main CLI function exists and is callable."""
# Just verify the function exists
assert callable(main)
def test_cli_chklint_subcommand():
"""Test the chklint CLI subcommand."""
# Test that the CLI can be invoked via fiona-assistant
result = subprocess.run(
[sys.executable, '-m', 'fiona.__main__', 'json-lint', 'chklint', 'src'],
capture_output=True,
text=True,
check=False,
cwd=str(REPO_ROOT)
)
# Should complete (may have errors if there are JSON violations)
assert result.returncode in [0, 1] # 0 = no violations, 1 = violations found
def test_readonly_zones_skipped():
"""Test that files in read-only zones are skipped."""
linter = JsonLinter()
# Create a temporary directory structure with personal/ subdirectory
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create personal directory
personal_dir = temp_path / 'personal'
personal_dir.mkdir()
# Create JSON file in personal directory
personal_file = personal_dir / 'test.json'
with open(personal_file, 'w') as f:
json.dump({"name": "test"}, f)
# Create valid JSON file in root
root_file = temp_path / 'valid.json'
with open(root_file, 'w') as f:
json.dump({"name": "test"}, f)
violations = linter.lint_directory(temp_path)
assert isinstance(violations, list)
# Files in personal/ should be skipped, so only root file is checked
# (and it's valid, so no violations)
assert len(violations) == 0
def test_respects_gitignore():
"""Test that .gitignore files are respected."""
linter = JsonLinter()
# Create a temporary directory with .gitignore
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create .gitignore
gitignore_file = temp_path / '.gitignore'
with open(gitignore_file, 'w') as f:
f.write('*.tmp.json\n')
# Create ignored JSON file
ignored_file = temp_path / 'test.tmp.json'
with open(ignored_file, 'w') as f:
json.dump({"name": "ignored"}, f)
# Create non-ignored JSON file
normal_file = temp_path / 'normal.json'
with open(normal_file, 'w') as f:
json.dump({"name": "normal"}, f)
violations = linter.lint_directory(temp_path)
assert isinstance(violations, list)
# Both files are valid, so no violations regardless of gitignore
assert len(violations) == 0
def test_lint_file_nonexistent():
"""Test linting a non-existent file raises appropriate error."""
linter = JsonLinter()
with pytest.raises(LinterError):
linter.lint_file(pathlib.Path('/nonexistent/file.json'))
def test_lint_directory_nonexistent():
"""Test linting a non-existent directory raises appropriate error."""
linter = JsonLinter()
with pytest.raises(LinterError):
linter.lint_directory(pathlib.Path('/nonexistent/directory'))
# Tests for _check_trailing_commas method
def test_check_trailing_commas_with_allow_true():
"""Test _check_trailing_commas when trailing commas are allowed."""
linter = JsonLinter()
linter.allow_trailing_commas = True
# Should return empty list when trailing commas are allowed
violations = linter._check_trailing_commas('{"a": 1,}')
assert violations == []
def test_check_trailing_commas_in_object():
"""Test _check_trailing_commas detects trailing comma in object."""
linter = JsonLinter()
linter.allow_trailing_commas = False
violations = linter._check_trailing_commas('{"a": 1,}')
assert len(violations) == 1
assert violations[0].code == "JSN003"
def test_check_trailing_commas_in_array():
"""Test _check_trailing_commas detects trailing comma in array."""
linter = JsonLinter()
linter.allow_trailing_commas = False
violations = linter._check_trailing_commas('[1, 2, 3,]')
assert len(violations) == 1
assert violations[0].code == "JSN003"
# Tests for _check_indentation method
def test_check_indentation_with_tabs():
"""Test _check_indentation detects tabs when spaces are expected."""
linter = JsonLinter()
linter.indent_type = "space"
linter.indent_length = 2
violations = linter._check_indentation('{\n\t"key": "value"\n}', pathlib.Path('test.json'))
assert len(violations) > 0
assert violations[0].code == "JSN002"
def test_check_indentation_with_spaces():
"""Test _check_indentation detects spaces when tabs are expected."""
linter = JsonLinter()
linter.indent_type = "tab"
linter.indent_length = 1
violations = linter._check_indentation('{\n "key": "value"\n}', pathlib.Path('test.json'))
assert len(violations) > 0
assert violations[0].code == "JSN002"
def test_check_indentation_mixed():
"""Test _check_indentation detects mixed tabs and spaces."""
linter = JsonLinter()
linter.indent_type = "tab"
linter.indent_length = 1
violations = linter._check_indentation('{\n\t "key": "value"\n}', pathlib.Path('test.json'))
assert len(violations) > 0
assert violations[0].code == "JSN002"
def test_check_indentation_wrong_length():
"""Test _check_indentation detects wrong indentation length."""
linter = JsonLinter()
linter.indent_type = "space"
linter.indent_length = 4
# 3 spaces instead of 4
violations = linter._check_indentation('{\n "key": "value"\n}', pathlib.Path('test.json'))
assert len(violations) > 0
assert violations[0].code == "JSN002"
# Tests for _check_duplicate_keys method
def test_check_duplicate_keys_disabled():
"""Test _check_duplicate_keys when check is disabled."""
linter = JsonLinter()
linter.check_duplicate_keys = False
violations = linter._check_duplicate_keys('{"a": 1, "a": 2}', pathlib.Path('test.json'))
assert violations == []
def test_check_duplicate_keys_enabled():
"""Test _check_duplicate_keys detects duplicate keys."""
linter = JsonLinter()
linter.check_duplicate_keys = True
# Note: Python's json.loads doesn't detect duplicate keys in the raw string
# but once parsed, dict only keeps the last value. We need actual duplicate detection.
# The implementation uses a custom check, so we test it.
violations = linter._check_duplicate_keys('{"a": 1, "a": 2}', pathlib.Path('test.json'))
# This may or may not detect duplicates depending on json.loads behavior
assert isinstance(violations, list)
# Tests for _check_line_length method
def test_check_line_length_disabled():
"""Test _check_line_length when max_line_length is None."""
linter = JsonLinter()
linter.max_line_length = None
violations = linter._check_line_length('{"key": "value"}' * 100, pathlib.Path('test.json'))
assert violations == []
def test_check_line_length_enabled():
"""Test _check_line_length detects long lines."""
linter = JsonLinter()
linter.max_line_length = 20
long_line = '{"key": "value with very very very long string"}'
violations = linter._check_line_length(long_line, pathlib.Path('test.json'))
assert len(violations) > 0
assert violations[0].code == "JSN006"
# Tests for _check_key_order method
def test_check_key_order_disabled():
"""Test _check_key_order when require_key_order is False."""
linter = JsonLinter()
linter.require_key_order = False
violations = linter._check_key_order('{"b": 1, "a": 2}', pathlib.Path('test.json'))
assert violations == []
def test_check_key_order_enabled():
"""Test _check_key_order detects unordered keys."""
linter = JsonLinter()
linter.require_key_order = True
violations = linter._check_key_order('{"b": 1, "a": 2}', pathlib.Path('test.json'))
assert len(violations) > 0
assert violations[0].code == "JSN005"
# Tests for lint_file error handling
def test_lint_file_not_a_file():
"""Test linting a directory instead of a file raises error."""
linter = JsonLinter()
with tempfile.TemporaryDirectory() as temp_dir, pytest.raises(LinterError):
linter.lint_file(pathlib.Path(temp_dir))
def test_lint_file_wrong_extension():
"""Test linting a non-JSON file returns empty violations."""
linter = JsonLinter()
with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
f.write('not json')
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
assert violations == []
finally:
pathlib.Path(temp_file).unlink()
def test_lint_file_read_error():
"""Test linting a file that can't be read raises error."""
linter = JsonLinter()
with pytest.raises(LinterError):
linter.lint_file(pathlib.Path('/dev/null/nonexistent.json'))
# Tests for fix_file method
def test_fix_file_not_a_file():
"""Test fixing a directory returns empty list."""
linter = JsonLinter()
with tempfile.TemporaryDirectory() as temp_dir:
fixed = linter.fix_file(pathlib.Path(temp_dir))
assert fixed == []
def test_fix_file_wrong_extension():
"""Test fixing a non-JSON file returns empty list."""
linter = JsonLinter()
with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
f.write('not json')
temp_file = f.name
try:
fixed = linter.fix_file(pathlib.Path(temp_file))
assert fixed == []
finally:
pathlib.Path(temp_file).unlink()
def test_fix_file_read_error():
"""Test fixing a file that can't be read returns empty list."""
linter = JsonLinter()
fixed = linter.fix_file(pathlib.Path('/dev/null/nonexistent.json'))
assert fixed == []
def test_fix_file_syntax_error():
"""Test fixing a file with syntax errors returns empty list."""
linter = JsonLinter()
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"invalid": }')
temp_file = f.name
try:
fixed = linter.fix_file(pathlib.Path(temp_file))
assert fixed == []
finally:
pathlib.Path(temp_file).unlink()
# Tests for fix_file with settings
def test_fix_file_with_indent_spaces():
"""Test fixing a file with space indentation settings."""
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as settings_f:
settings = {
"json": {
"indent": "space",
"indent_len": 2
}
}
json.dump(settings, settings_f)
settings_file = settings_f.name
try:
linter = JsonLinter(settings_file=pathlib.Path(settings_file))
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"a":1,"b":2}')
temp_file = f.name
try:
fixed = linter.fix_file(pathlib.Path(temp_file))
assert isinstance(fixed, list)
# Read the fixed file
with open(temp_file, 'r') as f:
content = f.read()
# Should have proper indentation
assert '\n' in content or content.count(' ') >= 2
finally:
pathlib.Path(temp_file).unlink()
finally:
pathlib.Path(settings_file).unlink()
def test_fix_file_with_indent_tabs():
"""Test fixing a file with tab indentation settings."""
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as settings_f:
settings = {
"json": {
"indent": "tab",
"indent_len": 1
}
}
json.dump(settings, settings_f)
settings_file = settings_f.name
try:
linter = JsonLinter(settings_file=pathlib.Path(settings_file))
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"a":1,"b":2}')
temp_file = f.name
try:
fixed = linter.fix_file(pathlib.Path(temp_file))
assert isinstance(fixed, list)
finally:
pathlib.Path(temp_file).unlink()
finally:
pathlib.Path(settings_file).unlink()
def test_fix_file_with_key_order():
"""Test fixing a file with key order settings."""
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as settings_f:
settings = {
"json": {
"require_key_order": True
}
}
json.dump(settings, settings_f)
settings_file = settings_f.name
try:
linter = JsonLinter(settings_file=pathlib.Path(settings_file))
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"b":1,"a":2}')
temp_file = f.name
try:
fixed = linter.fix_file(pathlib.Path(temp_file))
assert isinstance(fixed, list)
# Read the fixed file
with open(temp_file, 'r') as f:
content = f.read()
# Keys should be ordered
data = json.loads(content)
keys = list(data.keys())
assert keys == sorted(keys)
finally:
pathlib.Path(temp_file).unlink()
finally:
pathlib.Path(settings_file).unlink()
# Tests for check_json method
def test_check_json_directory():
"""Test check_json method scans a directory."""
linter = JsonLinter()
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create valid JSON file
valid_file = temp_path / 'valid.json'
with open(valid_file, 'w') as f:
json.dump({"name": "test"}, f)
result = linter.check_json(str(temp_path))
assert isinstance(result, str)
assert 'JSONLint' in result
# Tests for CLI main function
def test_main_with_chklint():
"""Test main function with chklint subcommand."""
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create valid JSON file
valid_file = temp_path / 'valid.json'
with open(valid_file, 'w') as f:
json.dump({"name": "test"}, f)
result = _run_jsonlint_cli(["jsonlint", "chklint", str(temp_path)])
assert result.returncode in [0, 1] # 0 = success, 1 = violations found
def test_main_with_fix():
"""Test main function with fix subcommand."""
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create JSON file to fix
test_file = temp_path / 'test.json'
with open(test_file, 'w') as f:
f.write('{"b":2,"a":1}')
result = _run_jsonlint_cli(["jsonlint", "fix", str(temp_path)])
assert result.returncode == 0
# Tests for settings loading
def test_settings_loading():
"""Test that settings are loaded correctly."""
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
settings = {
"json": {
"indent": "space",
"indent_len": 4,
"trailing_commas": True,
"require_key_order": True,
"check_duplicate_keys": False,
"max_line_length": 100,
"extensions": [".json", ".jsonc"]
}
}
json.dump(settings, f)
settings_file = f.name
try:
linter = JsonLinter(settings_file=pathlib.Path(settings_file))
assert linter.indent_type == "space"
assert linter.indent_length == 4
assert linter.allow_trailing_commas == True
assert linter.require_key_order == True
assert linter.check_duplicate_keys == False
assert linter.max_line_length == 100
assert ".jsonc" in linter.file_extensions
finally:
pathlib.Path(settings_file).unlink()
# Tests for default settings
def test_default_settings():
"""Test that default settings are applied."""
linter = JsonLinter()
assert linter.indent_type == "space"
assert linter.indent_length == 2
assert linter.allow_trailing_commas == False
assert linter.require_key_order == False
assert linter.check_duplicate_keys == True
assert linter.max_line_length is None
# Additional tests to improve coverage
def test_check_indentation_empty_line():
"""Test _check_indentation handles empty lines correctly."""
linter = JsonLinter()
linter.indent_type = "space"
linter.indent_length = 2
# File with empty line - should skip it
content = '{\n\n "key": "value"\n}'
violations = linter._check_indentation(content, pathlib.Path('test.json'))
assert isinstance(violations, list)
def test_check_indentation_no_leading_ws():
"""Test _check_indentation handles lines with no leading whitespace."""
linter = JsonLinter()
linter.indent_type = "space"
linter.indent_length = 2
# Line with no leading whitespace
content = '{"key": "value"}'
violations = linter._check_indentation(content, pathlib.Path('test.json'))
assert violations == []
def test_check_duplicate_keys_json_error():
"""Test _check_duplicate_keys handles JSONDecodeError."""
linter = JsonLinter()
linter.check_duplicate_keys = True
# Invalid JSON
violations = linter._check_duplicate_keys('{"invalid": }', pathlib.Path('test.json'))
# Should not crash, just return empty list
assert isinstance(violations, list)
def test_check_key_order_nested():
"""Test _check_key_order with nested objects."""
linter = JsonLinter()
linter.require_key_order = True
# Nested object with unordered keys
content = '{"outer": {"z": 1, "a": 2}, "inner": {"b": 3, "c": 4}}'
violations = linter._check_key_order(content, pathlib.Path('test.json'))
assert isinstance(violations, list)
def test_check_key_order_json_error():
"""Test _check_key_order handles JSONDecodeError."""
linter = JsonLinter()
linter.require_key_order = True
# Invalid JSON
violations = linter._check_key_order('{"invalid": }', pathlib.Path('test.json'))
# Should not crash
assert isinstance(violations, list)
def test_lint_file_json_syntax_error_with_details():
"""Test lint_file with JSON syntax error extracts line/column."""
linter = JsonLinter()
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"a": 1\n "b": 2,}') # Trailing comma
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
# Should have syntax error
assert len(violations) > 0
# Check that line numbers are extracted
assert all(hasattr(v, 'line') for v in violations)
assert all(hasattr(v, 'column') for v in violations)
finally:
pathlib.Path(temp_file).unlink()
def test_lint_file_empty_content():
"""Test lint_file with empty JSON content."""
linter = JsonLinter()
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('')
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
# Empty file should have syntax error
assert len(violations) > 0
finally:
pathlib.Path(temp_file).unlink()
def test_fix_file_with_all_settings():
"""Test fix_file with all settings enabled."""
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as settings_f:
settings = {
"json": {
"indent": "space",
"indent_len": 2,
"trailing_commas": False,
"require_key_order": True,
"check_duplicate_keys": True
}
}
json.dump(settings, settings_f)
settings_file = settings_f.name
try:
linter = JsonLinter(settings_file=pathlib.Path(settings_file))
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"b":2,"a":1}')
temp_file = f.name
try:
fixed = linter.fix_file(pathlib.Path(temp_file))
assert isinstance(fixed, list)
finally:
pathlib.Path(temp_file).unlink()
finally:
pathlib.Path(settings_file).unlink()
def test_fix_file_needs_fix_flag():
"""Test fix_file with needs_fix=True branch."""
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as settings_f:
settings = {
"json": {
"indent": "space",
"indent_len": 2,
"require_key_order": True
}
}
json.dump(settings, settings_f)
settings_file = settings_f.name
try:
linter = JsonLinter(settings_file=pathlib.Path(settings_file))
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"z":1,"a":2}') # Needs reordering
temp_file = f.name
try:
fixed = linter.fix_file(pathlib.Path(temp_file))
assert isinstance(fixed, list)
# File should have been fixed
with open(temp_file, 'r') as f:
content = f.read()
data = json.loads(content)
# Keys should be ordered
assert list(data.keys()) == sorted(data.keys())
finally:
pathlib.Path(temp_file).unlink()
finally:
pathlib.Path(settings_file).unlink()
def test_fix_file_oserror():
"""Test fix_file handles OSError gracefully."""
linter = JsonLinter()
# Try to fix a file that doesn't exist in a way that might cause OSError
fixed = linter.fix_file(pathlib.Path('/nonexistent/file.json'))
assert fixed == []
def test_check_json_empty_directory():
"""Test check_json with empty directory."""
linter = JsonLinter()
with tempfile.TemporaryDirectory() as temp_dir:
result = linter.check_json(temp_dir)
assert isinstance(result, str)
assert 'JSONLint' in result or 'No violations' in result
def test_lint_directory_with_mixed_files():
"""Test lint_directory with mix of valid and invalid JSON files."""
linter = JsonLinter()
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Valid JSON
valid_file = temp_path / 'valid.json'
with open(valid_file, 'w') as f:
json.dump({"name": "test"}, f)
# Invalid JSON
invalid_file = temp_path / 'invalid.json'
with open(invalid_file, 'w') as f:
f.write('{"invalid": }')
violations = linter.lint_directory(temp_path)
assert len(violations) > 0
def test_lint_file_with_frontmatter_json():
"""Test that JSON files are linted correctly."""
linter = JsonLinter()
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
json.dump({"name": "test", "version": "1.0.0"}, f, indent=2)
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
assert isinstance(violations, list)
finally:
pathlib.Path(temp_file).unlink()
# Tests for violation formatting
def test_violation_message_format():
"""Test that violation messages have correct format."""
linter = JsonLinter()
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"invalid": }')
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
if violations:
v = violations[0]
assert isinstance(v.message, str)
assert len(v.message) > 0
finally:
pathlib.Path(temp_file).unlink()
# Test to cover main() function by calling it directly
def test_main_function_coverage():
"""Test main function directly to improve coverage."""
# Save original argv and stdout
orig_argv = sys.argv
orig_stdout = sys.stdout
orig_stderr = sys.stderr
try:
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create a valid JSON file
valid_file = temp_path / 'test.json'
with open(valid_file, 'w') as f:
json.dump({"name": "test"}, f)
# Test chklint subcommand
sys.argv = ["jsonlint", "chklint", str(temp_path)]
sys.stdout = StringIO()
sys.stderr = StringIO()
try:
main()
except SystemExit:
pass
finally:
sys.stdout = orig_stdout
sys.stderr = orig_stderr
# Test fix subcommand
sys.argv = ["jsonlint", "fix", str(temp_path)]
sys.stdout = StringIO()
sys.stderr = StringIO()
try:
main()
except SystemExit:
pass
finally:
sys.stdout = orig_stdout
sys.stderr = orig_stderr
# Test with no subcommand (defaults to chklint)
sys.argv = ["jsonlint"]
sys.stdout = StringIO()
sys.stderr = StringIO()
try:
main()
except SystemExit:
pass
finally:
sys.stdout = orig_stdout
sys.stderr = orig_stderr
finally:
sys.argv = orig_argv
sys.stdout = orig_stdout
sys.stderr = orig_stderr
def test_main_with_nonexistent_directory():
"""Test main function with nonexistent directory."""
orig_argv = sys.argv
orig_stdout = sys.stdout
orig_stderr = sys.stderr
try:
sys.argv = ["jsonlint", "chklint", "/nonexistent/path"]
sys.stdout = StringIO()
sys.stderr = StringIO()
try:
main()
except SystemExit:
# main() calls sys.exit() on error
pass
except LinterError:
# lint_directory may raise LinterError for nonexistent directory
pass
finally:
sys.argv = orig_argv
sys.stdout = orig_stdout
sys.stderr = orig_stderr
def test_compress_violations_empty():
"""Test compress_violations with empty list."""
linter = JsonLinter()
compressed = linter.compress_violations([], pathlib.Path('test.json'))
assert isinstance(compressed, dict)
assert compressed['meta']['total_violations'] == 0
def test_format_compressed_violations_empty():
"""Test format_compressed_violations with empty violations."""
linter = JsonLinter()
# Use actual compressed_violations from compress_violations
compressed = linter.compress_violations([], pathlib.Path('test.json'))
formatted = linter.format_compressed_violations(compressed)
assert isinstance(formatted, str)
assert 'No violations' in formatted or len(formatted) > 0
# Additional CLI tests to improve main() coverage
def test_cli_with_invalid_json():
"""Test CLI with directory containing invalid JSON."""
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create invalid JSON file
invalid_file = temp_path / 'invalid.json'
with open(invalid_file, 'w') as f:
f.write('{"invalid": }')
result = _run_jsonlint_cli(["jsonlint", "chklint", str(temp_path)])
# Should exit with code 1 since there are violations
assert result.returncode == 1
assert 'JSN' in result.stdout or 'error' in result.stdout.lower()
def test_cli_fix_with_violations():
"""Test CLI fix command with files that have violations."""
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create JSON file with bad formatting
test_file = temp_path / 'test.json'
with open(test_file, 'w') as f:
f.write('{"b":2,"a":1}')
result = _run_jsonlint_cli(["jsonlint", "fix", str(temp_path)])
assert result.returncode == 0
assert 'file(s) fixed' in result.stdout.lower() or 'Fixed' in result.stdout
def test_cli_default_subcommand():
"""Test CLI with no subcommand defaults to chklint."""
with tempfile.TemporaryDirectory() as temp_dir:
temp_path = pathlib.Path(temp_dir)
# Create valid JSON file
valid_file = temp_path / 'valid.json'
with open(valid_file, 'w') as f:
json.dump({"name": "test"}, f)
# Run without subcommand (should default to chklint)
result = subprocess.run(
[sys.executable, '-c',
'from fiona.customlinter.jsonlint import main; import sys; sys.argv = ["jsonlint"]; main()'],
capture_output=True,
text=True,
check=False,
cwd=str(temp_path)
)
# Should still work (default to chklint with current directory)
assert result.returncode in [0, 1]
def test_cli_chklint_with_nonexistent():
"""Test CLI chklint with nonexistent directory."""
result = subprocess.run(
[sys.executable, '-c',
'from fiona.customlinter.jsonlint import main; import sys; sys.argv = ["jsonlint", "chklint", "/nonexistent/path"]; main()'],
capture_output=True,
text=True,
check=False
)
# Should exit with error
assert result.returncode == 1 or 'Error' in result.stderr
def test_cli_fix_with_nonexistent():
"""Test CLI fix with nonexistent directory."""
result = subprocess.run(
[sys.executable, '-c',
'from fiona.customlinter.jsonlint import main; import sys; sys.argv = ["jsonlint", "fix", "/nonexistent/path"]; main()'],
capture_output=True,
text=True,
check=False
)
# Should exit with error
assert result.returncode == 1 or 'Error' in result.stderr
# Tests for edge cases in lint_file
def test_lint_file_with_json_decode_error_no_lineno():
"""Test lint_file handles JSONDecodeError without lineno/colno attributes."""
linter = JsonLinter()
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{invalid}') # Invalid JSON
temp_file = f.name
try:
violations = linter.lint_file(pathlib.Path(temp_file))
assert len(violations) > 0
# Check that line and column are set (even if to 1)
assert all(v.line >= 1 for v in violations)
assert all(v.column >= 1 for v in violations)
finally:
pathlib.Path(temp_file).unlink()
def test_fix_file_with_type_error():
"""Test fix_file handles TypeError gracefully."""
linter = JsonLinter()
# Create a file with content that might cause TypeError when re-serializing
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
# Use a custom object that can't be serialized
f.write('{"a": 1}')
temp_file = f.name
try:
fixed = linter.fix_file(pathlib.Path(temp_file))
assert isinstance(fixed, list)
finally:
pathlib.Path(temp_file).unlink()
def test_fix_file_with_value_error():
"""Test fix_file handles ValueError gracefully."""
linter = JsonLinter()
with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
f.write('{"a": 1}')
temp_file = f.name
try:
fixed = linter.fix_file(pathlib.Path(temp_file))
assert isinstance(fixed, list)
finally:
pathlib.Path(temp_file).unlink()
# Tests to trigger specific branches
def test_check_key_order_with_nested_arrays():
"""Test _check_key_order with nested arrays."""
linter = JsonLinter()
linter.require_key_order = True
content = '{"b": [1, 2], "a": [3, 4]}'
violations = linter._check_key_order(content, pathlib.Path('test.json'))
assert isinstance(violations, list)
def test_check_line_length_multiline():
"""Test _check_line_length with multiline JSON."""
linter = JsonLinter()
linter.max_line_length = 10
content = '{"\n \"key\": \"value\"\n}'
violations = linter._check_line_length(content, pathlib.Path('test.json'))
assert isinstance(violations, list)