firefrost-gaming/skill-seekers-reference
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

run ruff

Browse Source
This commit is contained in:
Pablo Estevez
2026-01-17 17:29:21 +00:00
parent c89f059712
commit 5ed767ff9a
144 changed files with 14142 additions and 16488 deletions
Download Patch File Download Diff File Expand all files Collapse all files

245
tests/test_dependency_analyzer.py
View File

@@ -11,18 +11,13 @@ Test Coverage:
- Graph export (JSON, DOT, Mermaid)
"""
import unittest
import tempfile
import shutil
import json
from pathlib import Path
import tempfile
import unittest
try:
from skill_seekers.cli.dependency_analyzer import (
DependencyAnalyzer,
DependencyInfo,
FileNode
)
from skill_seekers.cli.dependency_analyzer import DependencyAnalyzer, DependencyInfo, FileNode
ANALYZER_AVAILABLE = True
except ImportError:
ANALYZER_AVAILABLE = False
@@ -39,46 +34,46 @@ class TestPythonImportExtraction(unittest.TestCase):
def test_simple_import(self):
"""Test simple import statement."""
code = "import os\nimport sys"
deps = self.analyzer.analyze_file('test.py', code, 'Python')
deps = self.analyzer.analyze_file("test.py", code, "Python")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'os')
self.assertEqual(deps[0].import_type, 'import')
self.assertEqual(deps[0].imported_module, "os")
self.assertEqual(deps[0].import_type, "import")
self.assertFalse(deps[0].is_relative)
def test_from_import(self):
"""Test from...import statement."""
code = "from pathlib import Path\nfrom typing import List"
deps = self.analyzer.analyze_file('test.py', code, 'Python')
deps = self.analyzer.analyze_file("test.py", code, "Python")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'pathlib')
self.assertEqual(deps[0].import_type, 'from')
self.assertEqual(deps[0].imported_module, "pathlib")
self.assertEqual(deps[0].import_type, "from")
def test_relative_import(self):
"""Test relative import."""
code = "from . import utils\nfrom ..common import helper"
deps = self.analyzer.analyze_file('test.py', code, 'Python')
deps = self.analyzer.analyze_file("test.py", code, "Python")
self.assertEqual(len(deps), 2)
self.assertTrue(deps[0].is_relative)
self.assertEqual(deps[0].imported_module, '.')
self.assertEqual(deps[0].imported_module, ".")
self.assertTrue(deps[1].is_relative)
self.assertEqual(deps[1].imported_module, '..common')
self.assertEqual(deps[1].imported_module, "..common")
def test_import_as(self):
"""Test import with alias."""
code = "import numpy as np\nimport pandas as pd"
deps = self.analyzer.analyze_file('test.py', code, 'Python')
deps = self.analyzer.analyze_file("test.py", code, "Python")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'numpy')
self.assertEqual(deps[1].imported_module, 'pandas')
self.assertEqual(deps[0].imported_module, "numpy")
self.assertEqual(deps[1].imported_module, "pandas")
def test_syntax_error_handling(self):
"""Test handling of syntax errors."""
code = "import os\nthis is not valid python\nimport sys"
deps = self.analyzer.analyze_file('test.py', code, 'Python')
deps = self.analyzer.analyze_file("test.py", code, "Python")
# Should return empty list due to syntax error
self.assertEqual(len(deps), 0)
@@ -95,30 +90,30 @@ class TestJavaScriptImportExtraction(unittest.TestCase):
def test_es6_import(self):
"""Test ES6 import statement."""
code = "import React from 'react';\nimport { useState } from 'react';"
deps = self.analyzer.analyze_file('test.js', code, 'JavaScript')
deps = self.analyzer.analyze_file("test.js", code, "JavaScript")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'react')
self.assertEqual(deps[0].import_type, 'import')
self.assertEqual(deps[0].imported_module, "react")
self.assertEqual(deps[0].import_type, "import")
self.assertFalse(deps[0].is_relative)
def test_commonjs_require(self):
"""Test CommonJS require statement."""
code = "const express = require('express');\nconst fs = require('fs');"
deps = self.analyzer.analyze_file('test.js', code, 'JavaScript')
deps = self.analyzer.analyze_file("test.js", code, "JavaScript")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'express')
self.assertEqual(deps[0].import_type, 'require')
self.assertEqual(deps[0].imported_module, "express")
self.assertEqual(deps[0].import_type, "require")
def test_relative_import_js(self):
"""Test relative imports in JavaScript."""
code = "import utils from './utils';\nimport config from '../config';"
deps = self.analyzer.analyze_file('test.js', code, 'JavaScript')
deps = self.analyzer.analyze_file("test.js", code, "JavaScript")
self.assertEqual(len(deps), 2)
self.assertTrue(deps[0].is_relative)
self.assertEqual(deps[0].imported_module, './utils')
self.assertEqual(deps[0].imported_module, "./utils")
self.assertTrue(deps[1].is_relative)
def test_mixed_imports(self):
@@ -128,13 +123,13 @@ import React from 'react';
const path = require('path');
import { Component } from '@angular/core';
"""
deps = self.analyzer.analyze_file('test.ts', code, 'TypeScript')
deps = self.analyzer.analyze_file("test.ts", code, "TypeScript")
self.assertEqual(len(deps), 3)
# Should find both import and require types
import_types = [dep.import_type for dep in deps]
self.assertIn('import', import_types)
self.assertIn('require', import_types)
self.assertIn("import", import_types)
self.assertIn("require", import_types)
class TestCppIncludeExtraction(unittest.TestCase):
@@ -148,20 +143,20 @@ class TestCppIncludeExtraction(unittest.TestCase):
def test_system_includes(self):
"""Test system header includes."""
code = "#include <iostream>\n#include <vector>\n#include <string>"
deps = self.analyzer.analyze_file('test.cpp', code, 'C++')
deps = self.analyzer.analyze_file("test.cpp", code, "C++")
self.assertEqual(len(deps), 3)
self.assertEqual(deps[0].imported_module, 'iostream')
self.assertEqual(deps[0].import_type, 'include')
self.assertEqual(deps[0].imported_module, "iostream")
self.assertEqual(deps[0].import_type, "include")
self.assertFalse(deps[0].is_relative) # <> headers are system headers
def test_local_includes(self):
"""Test local header includes."""
code = '#include "utils.h"\n#include "config.h"'
deps = self.analyzer.analyze_file('test.cpp', code, 'C++')
deps = self.analyzer.analyze_file("test.cpp", code, "C++")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'utils.h')
self.assertEqual(deps[0].imported_module, "utils.h")
self.assertTrue(deps[0].is_relative) # "" headers are local
def test_mixed_includes(self):
@@ -172,7 +167,7 @@ class TestCppIncludeExtraction(unittest.TestCase):
#include <vector>
#include "config.h"
"""
deps = self.analyzer.analyze_file('test.cpp', code, 'C++')
deps = self.analyzer.analyze_file("test.cpp", code, "C++")
self.assertEqual(len(deps), 4)
relative_count = sum(1 for dep in deps if dep.is_relative)
@@ -190,8 +185,8 @@ class TestDependencyGraphBuilding(unittest.TestCase):
def test_simple_graph(self):
"""Test building a simple dependency graph."""
# Create a simple dependency: main.py -> utils.py
self.analyzer.analyze_file('main.py', 'import utils', 'Python')
self.analyzer.analyze_file('utils.py', '', 'Python')
self.analyzer.analyze_file("main.py", "import utils", "Python")
self.analyzer.analyze_file("utils.py", "", "Python")
graph = self.analyzer.build_graph()
@@ -202,9 +197,9 @@ class TestDependencyGraphBuilding(unittest.TestCase):
def test_multiple_dependencies(self):
"""Test graph with multiple dependencies."""
# main.py imports utils.py and config.py
self.analyzer.analyze_file('main.py', 'import utils\nimport config', 'Python')
self.analyzer.analyze_file('utils.py', '', 'Python')
self.analyzer.analyze_file('config.py', '', 'Python')
self.analyzer.analyze_file("main.py", "import utils\nimport config", "Python")
self.analyzer.analyze_file("utils.py", "", "Python")
self.analyzer.analyze_file("config.py", "", "Python")
graph = self.analyzer.build_graph()
@@ -213,9 +208,9 @@ class TestDependencyGraphBuilding(unittest.TestCase):
def test_chain_dependencies(self):
"""Test chain of dependencies."""
# main -> utils -> helpers
self.analyzer.analyze_file('main.py', 'import utils', 'Python')
self.analyzer.analyze_file('utils.py', 'import helpers', 'Python')
self.analyzer.analyze_file('helpers.py', '', 'Python')
self.analyzer.analyze_file("main.py", "import utils", "Python")
self.analyzer.analyze_file("utils.py", "import helpers", "Python")
self.analyzer.analyze_file("helpers.py", "", "Python")
graph = self.analyzer.build_graph()
@@ -232,8 +227,8 @@ class TestCircularDependencyDetection(unittest.TestCase):
def test_no_circular_dependencies(self):
"""Test graph with no cycles."""
self.analyzer.analyze_file('main.py', 'import utils', 'Python')
self.analyzer.analyze_file('utils.py', '', 'Python')
self.analyzer.analyze_file("main.py", "import utils", "Python")
self.analyzer.analyze_file("utils.py", "", "Python")
self.analyzer.build_graph()
cycles = self.analyzer.detect_cycles()
@@ -244,8 +239,8 @@ class TestCircularDependencyDetection(unittest.TestCase):
"""Test detection of simple cycle."""
# Create circular dependency: a -> b -> a
# Using actual Python file extensions for proper resolution
self.analyzer.analyze_file('a.py', 'import b', 'Python')
self.analyzer.analyze_file('b.py', 'import a', 'Python')
self.analyzer.analyze_file("a.py", "import b", "Python")
self.analyzer.analyze_file("b.py", "import a", "Python")
self.analyzer.build_graph()
cycles = self.analyzer.detect_cycles()
@@ -257,9 +252,9 @@ class TestCircularDependencyDetection(unittest.TestCase):
def test_three_way_cycle(self):
"""Test detection of three-way cycle."""
# a -> b -> c -> a
self.analyzer.analyze_file('a.py', 'import b', 'Python')
self.analyzer.analyze_file('b.py', 'import c', 'Python')
self.analyzer.analyze_file('c.py', 'import a', 'Python')
self.analyzer.analyze_file("a.py", "import b", "Python")
self.analyzer.analyze_file("b.py", "import c", "Python")
self.analyzer.analyze_file("c.py", "import a", "Python")
self.analyzer.build_graph()
cycles = self.analyzer.detect_cycles()
@@ -281,43 +276,43 @@ class TestGraphExport(unittest.TestCase):
def test_export_json(self):
"""Test JSON export."""
self.analyzer.analyze_file('main.py', 'import utils', 'Python')
self.analyzer.analyze_file('utils.py', '', 'Python')
self.analyzer.analyze_file("main.py", "import utils", "Python")
self.analyzer.analyze_file("utils.py", "", "Python")
self.analyzer.build_graph()
json_data = self.analyzer.export_json()
self.assertIn('nodes', json_data)
self.assertIn('edges', json_data)
self.assertEqual(len(json_data['nodes']), 2)
self.assertIn("nodes", json_data)
self.assertIn("edges", json_data)
self.assertEqual(len(json_data["nodes"]), 2)
self.assertIsInstance(json_data, dict)
def test_export_mermaid(self):
"""Test Mermaid diagram export."""
self.analyzer.analyze_file('main.py', 'import utils', 'Python')
self.analyzer.analyze_file('utils.py', '', 'Python')
self.analyzer.analyze_file("main.py", "import utils", "Python")
self.analyzer.analyze_file("utils.py", "", "Python")
self.analyzer.build_graph()
mermaid = self.analyzer.export_mermaid()
self.assertIsInstance(mermaid, str)
self.assertIn('graph TD', mermaid)
self.assertIn('N0', mermaid) # Node IDs
self.assertIn("graph TD", mermaid)
self.assertIn("N0", mermaid) # Node IDs
def test_get_statistics(self):
"""Test graph statistics."""
self.analyzer.analyze_file('main.py', 'import utils\nimport config', 'Python')
self.analyzer.analyze_file('utils.py', 'import helpers', 'Python')
self.analyzer.analyze_file('config.py', '', 'Python')
self.analyzer.analyze_file('helpers.py', '', 'Python')
self.analyzer.analyze_file("main.py", "import utils\nimport config", "Python")
self.analyzer.analyze_file("utils.py", "import helpers", "Python")
self.analyzer.analyze_file("config.py", "", "Python")
self.analyzer.analyze_file("helpers.py", "", "Python")
self.analyzer.build_graph()
stats = self.analyzer.get_statistics()
self.assertIn('total_files', stats)
self.assertIn('total_dependencies', stats)
self.assertIn('circular_dependencies', stats)
self.assertEqual(stats['total_files'], 4)
self.assertIn("total_files", stats)
self.assertIn("total_dependencies", stats)
self.assertIn("circular_dependencies", stats)
self.assertEqual(stats["total_files"], 4)
class TestCSharpImportExtraction(unittest.TestCase):
@@ -331,28 +326,28 @@ class TestCSharpImportExtraction(unittest.TestCase):
def test_simple_using(self):
"""Test simple using statement."""
code = "using System;\nusing System.Collections.Generic;"
deps = self.analyzer.analyze_file('test.cs', code, 'C#')
deps = self.analyzer.analyze_file("test.cs", code, "C#")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'System')
self.assertEqual(deps[0].import_type, 'using')
self.assertEqual(deps[0].imported_module, "System")
self.assertEqual(deps[0].import_type, "using")
self.assertFalse(deps[0].is_relative)
def test_using_alias(self):
"""Test using statement with alias."""
code = "using Project = PC.MyCompany.Project;"
deps = self.analyzer.analyze_file('test.cs', code, 'C#')
deps = self.analyzer.analyze_file("test.cs", code, "C#")
self.assertEqual(len(deps), 1)
self.assertEqual(deps[0].imported_module, 'PC.MyCompany.Project')
self.assertEqual(deps[0].imported_module, "PC.MyCompany.Project")
def test_using_static(self):
"""Test static using."""
code = "using static System.Math;"
deps = self.analyzer.analyze_file('test.cs', code, 'C#')
deps = self.analyzer.analyze_file("test.cs", code, "C#")
self.assertEqual(len(deps), 1)
self.assertEqual(deps[0].imported_module, 'System.Math')
self.assertEqual(deps[0].imported_module, "System.Math")
class TestGoImportExtraction(unittest.TestCase):
@@ -366,35 +361,35 @@ class TestGoImportExtraction(unittest.TestCase):
def test_simple_import(self):
"""Test simple import statement."""
code = 'import "fmt"\nimport "os"'
deps = self.analyzer.analyze_file('test.go', code, 'Go')
deps = self.analyzer.analyze_file("test.go", code, "Go")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'fmt')
self.assertEqual(deps[0].import_type, 'import')
self.assertEqual(deps[0].imported_module, "fmt")
self.assertEqual(deps[0].import_type, "import")
self.assertFalse(deps[0].is_relative)
def test_import_with_alias(self):
"""Test import with alias."""
code = 'import f "fmt"'
deps = self.analyzer.analyze_file('test.go', code, 'Go')
deps = self.analyzer.analyze_file("test.go", code, "Go")
self.assertEqual(len(deps), 1)
self.assertEqual(deps[0].imported_module, 'fmt')
self.assertEqual(deps[0].imported_module, "fmt")
def test_multi_import_block(self):
"""Test multi-import block."""
code = '''import (
code = """import (
"fmt"
"os"
"io"
)'''
deps = self.analyzer.analyze_file('test.go', code, 'Go')
)"""
deps = self.analyzer.analyze_file("test.go", code, "Go")
self.assertEqual(len(deps), 3)
modules = [dep.imported_module for dep in deps]
self.assertIn('fmt', modules)
self.assertIn('os', modules)
self.assertIn('io', modules)
self.assertIn("fmt", modules)
self.assertIn("os", modules)
self.assertIn("io", modules)
class TestRustImportExtraction(unittest.TestCase):
@@ -408,26 +403,26 @@ class TestRustImportExtraction(unittest.TestCase):
def test_simple_use(self):
"""Test simple use statement."""
code = "use std::collections::HashMap;\nuse std::io;"
deps = self.analyzer.analyze_file('test.rs', code, 'Rust')
deps = self.analyzer.analyze_file("test.rs", code, "Rust")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'std::collections::HashMap')
self.assertEqual(deps[0].import_type, 'use')
self.assertEqual(deps[0].imported_module, "std::collections::HashMap")
self.assertEqual(deps[0].import_type, "use")
self.assertFalse(deps[0].is_relative)
def test_use_crate(self):
"""Test use with crate keyword."""
code = "use crate::module::Item;"
deps = self.analyzer.analyze_file('test.rs', code, 'Rust')
deps = self.analyzer.analyze_file("test.rs", code, "Rust")
self.assertEqual(len(deps), 1)
self.assertEqual(deps[0].imported_module, 'crate::module::Item')
self.assertEqual(deps[0].imported_module, "crate::module::Item")
self.assertFalse(deps[0].is_relative)
def test_use_super(self):
"""Test use with super keyword."""
code = "use super::sibling;"
deps = self.analyzer.analyze_file('test.rs', code, 'Rust')
deps = self.analyzer.analyze_file("test.rs", code, "Rust")
self.assertEqual(len(deps), 1)
self.assertTrue(deps[0].is_relative)
@@ -435,12 +430,12 @@ class TestRustImportExtraction(unittest.TestCase):
def test_use_curly_braces(self):
"""Test use with curly braces."""
code = "use std::{io, fs};"
deps = self.analyzer.analyze_file('test.rs', code, 'Rust')
deps = self.analyzer.analyze_file("test.rs", code, "Rust")
self.assertEqual(len(deps), 2)
modules = [dep.imported_module for dep in deps]
self.assertIn('std::io', modules)
self.assertIn('std::fs', modules)
self.assertIn("std::io", modules)
self.assertIn("std::fs", modules)
class TestJavaImportExtraction(unittest.TestCase):
@@ -454,28 +449,28 @@ class TestJavaImportExtraction(unittest.TestCase):
def test_simple_import(self):
"""Test simple import statement."""
code = "import java.util.List;\nimport java.io.File;"
deps = self.analyzer.analyze_file('test.java', code, 'Java')
deps = self.analyzer.analyze_file("test.java", code, "Java")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'java.util.List')
self.assertEqual(deps[0].import_type, 'import')
self.assertEqual(deps[0].imported_module, "java.util.List")
self.assertEqual(deps[0].import_type, "import")
self.assertFalse(deps[0].is_relative)
def test_wildcard_import(self):
"""Test wildcard import."""
code = "import java.util.*;"
deps = self.analyzer.analyze_file('test.java', code, 'Java')
deps = self.analyzer.analyze_file("test.java", code, "Java")
self.assertEqual(len(deps), 1)
self.assertEqual(deps[0].imported_module, 'java.util.*')
self.assertEqual(deps[0].imported_module, "java.util.*")
def test_static_import(self):
"""Test static import."""
code = "import static java.lang.Math.PI;"
deps = self.analyzer.analyze_file('test.java', code, 'Java')
deps = self.analyzer.analyze_file("test.java", code, "Java")
self.assertEqual(len(deps), 1)
self.assertEqual(deps[0].imported_module, 'java.lang.Math.PI')
self.assertEqual(deps[0].imported_module, "java.lang.Math.PI")
class TestRubyImportExtraction(unittest.TestCase):
@@ -489,30 +484,30 @@ class TestRubyImportExtraction(unittest.TestCase):
def test_simple_require(self):
"""Test simple require statement."""
code = "require 'json'\nrequire 'net/http'"
deps = self.analyzer.analyze_file('test.rb', code, 'Ruby')
deps = self.analyzer.analyze_file("test.rb", code, "Ruby")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'json')
self.assertEqual(deps[0].import_type, 'require')
self.assertEqual(deps[0].imported_module, "json")
self.assertEqual(deps[0].import_type, "require")
self.assertFalse(deps[0].is_relative)
def test_require_relative(self):
"""Test require_relative statement."""
code = "require_relative 'helper'\nrequire_relative '../utils'"
deps = self.analyzer.analyze_file('test.rb', code, 'Ruby')
deps = self.analyzer.analyze_file("test.rb", code, "Ruby")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'helper')
self.assertEqual(deps[0].import_type, 'require_relative')
self.assertEqual(deps[0].imported_module, "helper")
self.assertEqual(deps[0].import_type, "require_relative")
self.assertTrue(deps[0].is_relative)
def test_load_statement(self):
"""Test load statement."""
code = "load 'script.rb'"
deps = self.analyzer.analyze_file('test.rb', code, 'Ruby')
deps = self.analyzer.analyze_file("test.rb", code, "Ruby")
self.assertEqual(len(deps), 1)
self.assertEqual(deps[0].import_type, 'load')
self.assertEqual(deps[0].import_type, "load")
self.assertTrue(deps[0].is_relative)
@@ -527,29 +522,29 @@ class TestPHPImportExtraction(unittest.TestCase):
def test_require_statement(self):
"""Test require statement."""
code = "<?php\nrequire 'config.php';\nrequire_once 'database.php';"
deps = self.analyzer.analyze_file('test.php', code, 'PHP')
deps = self.analyzer.analyze_file("test.php", code, "PHP")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'config.php')
self.assertEqual(deps[0].import_type, 'require')
self.assertEqual(deps[0].imported_module, "config.php")
self.assertEqual(deps[0].import_type, "require")
self.assertTrue(deps[0].is_relative)
def test_include_statement(self):
"""Test include statement."""
code = "<?php\ninclude 'header.php';\ninclude_once 'footer.php';"
deps = self.analyzer.analyze_file('test.php', code, 'PHP')
deps = self.analyzer.analyze_file("test.php", code, "PHP")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].import_type, 'include')
self.assertEqual(deps[0].import_type, "include")
def test_namespace_use(self):
"""Test namespace use statement."""
code = "<?php\nuse App\\Models\\User;\nuse Illuminate\\Support\\Facades\\DB;"
deps = self.analyzer.analyze_file('test.php', code, 'PHP')
deps = self.analyzer.analyze_file("test.php", code, "PHP")
self.assertEqual(len(deps), 2)
self.assertEqual(deps[0].imported_module, 'App\\Models\\User')
self.assertEqual(deps[0].import_type, 'use')
self.assertEqual(deps[0].imported_module, "App\\Models\\User")
self.assertEqual(deps[0].import_type, "use")
self.assertFalse(deps[0].is_relative)
@@ -563,24 +558,24 @@ class TestEdgeCases(unittest.TestCase):
def test_empty_file(self):
"""Test analysis of empty file."""
deps = self.analyzer.analyze_file('empty.py', '', 'Python')
deps = self.analyzer.analyze_file("empty.py", "", "Python")
self.assertEqual(len(deps), 0)
def test_unsupported_language(self):
"""Test handling of unsupported language."""
code = "BEGIN { print $0 }"
deps = self.analyzer.analyze_file('test.awk', code, 'AWK')
deps = self.analyzer.analyze_file("test.awk", code, "AWK")
self.assertEqual(len(deps), 0)
def test_file_with_only_comments(self):
"""Test file with only comments."""
code = "# This is a comment\n# Another comment"
deps = self.analyzer.analyze_file('test.py', code, 'Python')
deps = self.analyzer.analyze_file("test.py", code, "Python")
self.assertEqual(len(deps), 0)
if __name__ == '__main__':
if __name__ == "__main__":
unittest.main(verbosity=2)