@@ -116,9 +119,8 @@ def test_remove_unused_exports(tmpdir) -> None:
)
}
"""
- adj_filename = "adjacent.tsx"
# language=typescript jsx
- adj_content = """
+ ADJ_CONTENT = """
import MainComponent from 'Component'
import { SharedComponent } from 'Component'
import { StateComponent } from 'utils'
@@ -127,26 +129,79 @@ def test_remove_unused_exports(tmpdir) -> None:
return (
)
}
"""
- misc_filename = "misc.tsx"
# language=typescript jsx
- misc_content = """
+ MISC_CONTENT = """
export { UnusedComponent } from 'Component'
function Helper({ props }: HelperProps) {}
export { Helper }
"""
- import_filename = "import.tsx"
# language=typescript jsx
- import_content = """
+ IMPORT_CONTENT = """
import { UnusedComponent } from 'misc'
"""
- files = {src_filename: src_content, adj_filename: adj_content, misc_filename: misc_content, import_filename: import_content}
+ # ========== [ AFTER ] ==========
+ # language=typescript jsx
+ EXPECTED_SRC_CONTENT = """
+import { SubComponent } from 'new';
+
+export default function MainComponent() {
+ const [state, setState] = useState
()
+ return ()
+}
+
+export function UnusedComponent({ props }: UnusedProps) {
+ return (
+ Unused
+ )
+}
+"""
+ # language=typescript jsx
+ EXPECTED_NEW_CONTENT = """
+export function SubComponent({ props }: SubComponentProps) {
+ return (
+
+ )
+}
+
+function HelperComponent({ props }: HelperComponentProps) {
+ return (
+
+ )
+}
+
+export function SharedComponent({ props }: SharedComponentProps) {
+ return (
+
+ )
+}
+"""
+ # language=typescript jsx
+ EXPECTED_ADJ_CONTENT = """
+import MainComponent from 'Component'
+import { SharedComponent } from 'new'
+import { StateComponent } from 'utils'
+
+function Container(props: ContainerProps) {
+ return ()
+}
+"""
+ # language=typescript jsx
+ EXPECTED_MISC_CONTENT = """
+function Helper({ props }: HelperProps) {}
+"""
+
+ files = {"Component.tsx": SRC_CONTENT, "adjacent.tsx": ADJ_CONTENT, "misc.tsx": MISC_CONTENT, "import.tsx": IMPORT_CONTENT}
with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.TYPESCRIPT, files=files) as codebase:
- src_file = codebase.get_file(src_filename)
- adj_file = codebase.get_file(adj_filename)
- misc_file = codebase.get_file(misc_filename)
+ src_file = codebase.get_file("Component.tsx")
+ adj_file = codebase.get_file("adjacent.tsx")
+ misc_file = codebase.get_file("misc.tsx")
new_file = codebase.create_file("new.tsx")
sub_component = src_file.get_symbol("SubComponent")
@@ -159,20 +214,7 @@ def test_remove_unused_exports(tmpdir) -> None:
src_file.remove_unused_exports()
misc_file.remove_unused_exports()
- # Verify exports in new file
- assert "export function SubComponent" in new_file.content
- assert "function HelperComponent" in new_file.content
- assert "export function HelperComponent" not in new_file.content
- assert "export function SharedComponent" in new_file.content
-
- # Verify imports updated
- assert "import { SharedComponent } from 'new'" in adj_file.content
-
- # Verify original file exports
- assert "export default function MainComponent()" in src_file.content
- assert "function UnusedComponent" in src_file.content
- assert "export function UnusedComponent" not in src_file.content
-
- # Verify misc file exports cleaned up
- assert "export { Helper }" not in misc_file.content
- assert "export { UnusedComponent } from 'Component'" not in misc_file.content
+ assert src_file.content.strip() == EXPECTED_SRC_CONTENT.strip()
+ assert new_file.content.strip() == EXPECTED_NEW_CONTENT.strip()
+ assert adj_file.content.strip() == EXPECTED_ADJ_CONTENT.strip()
+ assert misc_file.content.strip() == EXPECTED_MISC_CONTENT.strip()
diff --git a/tests/unit/codegen/sdk/typescript/namespace/test_namespace.py b/tests/unit/codegen/sdk/typescript/namespace/test_namespace.py
index aed6271b9..ab0764f76 100644
--- a/tests/unit/codegen/sdk/typescript/namespace/test_namespace.py
+++ b/tests/unit/codegen/sdk/typescript/namespace/test_namespace.py
@@ -65,8 +65,7 @@ def test_namespace_basic_symbols(tmpdir) -> None:
assert namespace.get_symbol("privateVar") is None # private not accessible
# Test symbols collection
- assert len(namespace.symbols) == 2 # only exported symbols
- assert all(symbol.is_exported for symbol in namespace.symbols)
+ assert len(namespace.symbols) == 3
def test_namespace_recursive_symbol_lookup(tmpdir) -> None:
@@ -124,44 +123,6 @@ def test_namespace_functions(tmpdir) -> None:
assert all(func.is_exported for func in namespace.functions)
-def test_namespace_function_full_name(tmpdir) -> None:
- """Test getting functions using full names."""
- FILE_NAME = "test.ts"
- # language=typescript
- FILE_CONTENT = """
- namespace Outer {
- export function shared() { return 1; }
- export namespace Inner {
- export function shared() { return 2; }
- export function unique() { return 3; }
- }
- }
- """
- with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.TYPESCRIPT, files={FILE_NAME: FILE_CONTENT}) as codebase:
- namespace: TSNamespace = codebase.get_symbol("Outer")
- assert namespace is not None
-
- # Test getting functions by local name
- outer_shared = namespace.get_function("shared", recursive=False)
- assert outer_shared is not None
- inner_shared = namespace.get_function("shared", recursive=True)
- assert inner_shared is not None
- # Without full names, we might get either shared function
- assert outer_shared == inner_shared
-
- # Test getting functions by full name
- outer_shared = namespace.get_function("shared", use_full_name=True)
- assert outer_shared is not None
- inner_shared = namespace.get_function("Inner.shared", use_full_name=True)
- assert inner_shared is not None
- inner_unique = namespace.get_function("Inner.unique", use_full_name=True)
- assert inner_unique is not None
-
- # Test non-existent paths
- assert namespace.get_function("NonExistent.shared", use_full_name=True) is None
- assert namespace.get_function("Inner.NonExistent", use_full_name=True) is None
-
-
def test_namespace_function_overloading(tmpdir) -> None:
"""Test function overloading within namespace."""
FILE_NAME = "test.ts"
@@ -333,3 +294,46 @@ def test_namespace_nested_deep(tmpdir) -> None:
assert len(nested) == 2 # Should find B and C
assert all(isinstance(ns, TSNamespace) for ns in nested)
assert {ns.name for ns in nested} == {"B", "C"}
+
+
+def test_namespace_imports(tmpdir) -> None:
+ """Test importing and using namespaces."""
+ FILE_NAME_1 = "math.ts"
+ # language=typescript
+ FILE_CONTENT_1 = """
+ export namespace Math {
+ export const PI = 3.14159;
+ export function square(x: number) { return x * x; }
+
+ export namespace Advanced {
+ export function cube(x: number) { return x * x * x; }
+ }
+ }
+ """
+
+ FILE_NAME_2 = "app.ts"
+ # language=typescript
+ FILE_CONTENT_2 = """
+ import { Math } from './math';
+
+ console.log(Math.PI);
+ console.log(Math.square(5));
+ console.log(Math.Advanced.cube(3));
+ """
+
+ with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.TYPESCRIPT, files={FILE_NAME_1: FILE_CONTENT_1, FILE_NAME_2: FILE_CONTENT_2}) as codebase:
+ math_ns = codebase.get_symbol("Math")
+ assert math_ns is not None
+ assert math_ns.name == "Math"
+
+ # Test namespace import resolution
+ file2 = codebase.get_file(FILE_NAME_2)
+ math_import = file2.get_import("Math")
+ assert math_import is not None
+ assert math_import.is_namespace_import
+
+ # Test nested namespace access
+ advanced = math_ns.get_namespace("Advanced")
+ assert advanced is not None
+ assert advanced.name == "Advanced"
+ assert advanced.get_function("cube") is not None
diff --git a/tests/unit/codegen/sdk/typescript/namespace/test_namespace_complex_examples.py b/tests/unit/codegen/sdk/typescript/namespace/test_namespace_complex_examples.py
index 3dfa77e28..9af4baf6f 100644
--- a/tests/unit/codegen/sdk/typescript/namespace/test_namespace_complex_examples.py
+++ b/tests/unit/codegen/sdk/typescript/namespace/test_namespace_complex_examples.py
@@ -133,3 +133,42 @@ def test_namespace_validators(tmpdir) -> None:
# Verify non-exported items are not accessible
assert namespace.get_symbol("lettersRegexp") is None
assert namespace.get_symbol("numberRegexp") is None
+
+
+def test_namespace_wildcard_import(tmpdir) -> None:
+ """Test wildcard imports with namespaces."""
+ FILE_NAME_1 = "utils.ts"
+ # language=typescript
+ FILE_CONTENT_1 = """
+ export namespace Utils {
+ export const helper1 = () => "help1";
+ export const helper2 = () => "help2";
+ const internal = () => "internal";
+ }
+ """
+
+ FILE_NAME_2 = "app.ts"
+ # language=typescript
+ FILE_CONTENT_2 = """
+ import * as AllUtils from './utils';
+
+ function test() {
+ console.log(AllUtils.Utils.helper1());
+ console.log(AllUtils.Utils.helper2());
+ }
+ """
+
+ with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.TYPESCRIPT, files={FILE_NAME_1: FILE_CONTENT_1, FILE_NAME_2: FILE_CONTENT_2}) as codebase:
+ utils_file = codebase.get_file(FILE_NAME_1)
+ app_file = codebase.get_file(FILE_NAME_2)
+
+ # Verify namespace import
+ utils_import = app_file.get_import("AllUtils")
+ assert utils_import is not None
+ assert utils_import.namespace == "AllUtils"
+
+ # Verify access to exported symbols
+ utils_ns = utils_file.get_symbol("Utils")
+ assert "helper1" in utils_ns.valid_import_names
+ assert "helper2" in utils_ns.valid_import_names
+ assert "internal" not in utils_ns.valid_import_names
diff --git a/tests/unit/codegen/sdk/typescript/namespace/test_namespace_modifications.py b/tests/unit/codegen/sdk/typescript/namespace/test_namespace_modifications.py
new file mode 100644
index 000000000..fc592beac
--- /dev/null
+++ b/tests/unit/codegen/sdk/typescript/namespace/test_namespace_modifications.py
@@ -0,0 +1,183 @@
+from typing import TYPE_CHECKING
+
+import pytest
+
+from codegen.sdk.codebase.factory.get_session import get_codebase_session
+from codegen.shared.enums.programming_language import ProgrammingLanguage
+
+if TYPE_CHECKING:
+ from codegen.sdk.typescript.namespace import TSNamespace
+
+
+def test_namespace_add_symbol(tmpdir) -> None:
+ """Test adding symbols to namespace."""
+ FILE_NAME = "test.ts"
+ # language=typescript
+ FILE_CONTENT = """
+ namespace MyNamespace {
+ export const x = 1;
+ }
+ """
+ with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.TYPESCRIPT, files={FILE_NAME: FILE_CONTENT}) as codebase:
+ file = codebase.get_file("test.ts")
+ namespace: TSNamespace = codebase.get_symbol("MyNamespace")
+
+ # 1. a) Add new symbol from object, then manually remove the original symbol from the file
+ # 1. b) Add new symbol by moving operation
+ file.add_symbol_from_source(source="const ya = 2")
+ codebase.ctx.commit_transactions()
+ new_const = file.get_symbol("ya")
+
+ # Store original location
+
+ # Add to namespace and remove from original location
+ namespace.add_symbol(new_const, should_export=True)
+
+ codebase.ctx.commit_transactions()
+
+ # Get fresh reference to namespace
+ namespace: TSNamespace = codebase.get_symbol("MyNamespace")
+
+ # Verify symbols were moved correctly
+ assert namespace.get_symbol("ya") is not None
+ assert namespace.get_symbol("ya").export is not None
+
+ # 2. Add new symbol from string
+ code = "const z = 3"
+ namespace.add_symbol_from_source(code)
+ codebase.ctx.commit_transactions()
+ namespace: TSNamespace = codebase.get_symbol("MyNamespace")
+
+ code_symbol = namespace.get_symbol("z", get_private=True)
+ # Verify exported symbol
+ assert code_symbol is not None
+ assert code_symbol.name == "z"
+
+ assert len(namespace.symbols) == 3
+ assert {s.name for s in namespace.symbols} == {"x", "ya", "z"}
+
+
+def test_namespace_remove_symbol(tmpdir) -> None:
+ """Test removing symbols from namespace."""
+ FILE_NAME = "test.ts"
+ # language=typescript
+ FILE_CONTENT = """
+ namespace MyNamespace {
+ export const x = 1;
+ export const y = 2;
+ }
+ """
+ with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.TYPESCRIPT, files={FILE_NAME: FILE_CONTENT}) as codebase:
+ namespace: TSNamespace = codebase.get_symbol("MyNamespace")
+
+ # Remove existing symbol
+ removed = namespace.remove_symbol("x")
+ codebase.ctx.commit_transactions()
+ assert removed is not None
+ assert removed.name == "x"
+
+ # Verify symbol was removed
+ assert namespace.get_symbol("x") is None
+ assert len(namespace.symbols) == 1
+ assert namespace.symbols[0].name == "y"
+
+ # Try removing non-existent symbol
+ assert namespace.remove_symbol("z") is None
+
+
+def test_namespace_rename(tmpdir) -> None:
+ """Test renaming namespace."""
+ FILE_NAME = "test.ts"
+ # language=typescript
+ FILE_CONTENT = """
+ namespace OldName {
+ export const x = 1;
+ }
+ """
+ with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.TYPESCRIPT, files={FILE_NAME: FILE_CONTENT}) as codebase:
+ namespace: TSNamespace = codebase.get_symbol("OldName")
+
+ # Rename namespace
+ namespace.rename("NewName")
+ codebase.ctx.commit_transactions()
+
+ # Verify rename
+ namespace: TSNamespace = codebase.get_symbol("NewName")
+ assert namespace.name == "NewName"
+ assert codebase.get_symbol("NewName") is namespace
+ assert codebase.get_symbol("OldName", optional=True) is None
+
+
+def test_namespace_export_symbol(tmpdir) -> None:
+ """Test exporting symbols in namespace."""
+ FILE_NAME = "test.ts"
+ # language=typescript
+ FILE_CONTENT = """
+ namespace ExportTest {
+ export const external = 123;
+ const internal = 123;
+ }
+ """
+ with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.TYPESCRIPT, files={FILE_NAME: FILE_CONTENT}) as codebase:
+ namespace: TSNamespace = codebase.get_symbol("ExportTest")
+
+ # Export internal symbol
+ namespace.export_symbol("internal")
+ codebase.ctx.commit_transactions()
+
+ # Verify export
+ namespace: TSNamespace = codebase.get_symbol("ExportTest")
+ internal = namespace.get_symbol("internal")
+ assert internal is not None
+ assert all(symbol.is_exported for symbol in namespace.symbols)
+
+ # Export already exported symbol (no change)
+ namespace.export_symbol("external")
+ codebase.ctx.commit_transactions()
+
+ namespace: TSNamespace = codebase.get_symbol("ExportTest")
+ external = namespace.get_symbol("external")
+ assert external is not None
+ assert external.is_exported
+
+
+@pytest.mark.skip("TODO: Symbol Animals is ambiguous in codebase - more than one instance")
+def test_namespace_merging(tmpdir) -> None:
+ """Test TypeScript namespace merging functionality."""
+ FILE_NAME = "test.ts"
+ # language=typescript
+ FILE_CONTENT = """
+ namespace Animals {
+ export class Dog { bark() {} }
+ }
+
+ namespace Animals { // Merge with previous namespace
+ export class Cat { meow() {} }
+ }
+
+ namespace Plants { // Different namespace, should not merge
+ export class Tree {}
+ }
+ """
+ with get_codebase_session(tmpdir=tmpdir, programming_language=ProgrammingLanguage.TYPESCRIPT, files={FILE_NAME: FILE_CONTENT}) as codebase:
+ animals = codebase.get_symbol("Animals")
+ assert animals is not None
+
+ # Test merged namespace access
+ assert animals.get_class("Dog") is not None
+ assert animals.get_class("Cat") is not None
+
+ # Verify merged namespaces
+ assert len(animals.merged_namespaces) == 1
+ merged = animals.merged_namespaces[0]
+ assert merged.name == "Animals"
+ assert merged != animals
+
+ # Verify all symbols accessible
+ all_symbols = animals.symbols
+ assert len(all_symbols) == 2
+ assert {s.name for s in all_symbols} == {"Dog", "Cat"}
+
+ # Verify non-merged namespace
+ plants = codebase.get_symbol("Plants")
+ assert len(plants.merged_namespaces) == 0
diff --git a/tests/unit/codegen/sdk/typescript/namespace/test_namespace_usage.py b/tests/unit/codegen/sdk/typescript/namespace/test_namespace_usage.py
new file mode 100644
index 000000000..9f72250b0
--- /dev/null
+++ b/tests/unit/codegen/sdk/typescript/namespace/test_namespace_usage.py
@@ -0,0 +1,103 @@
+from codegen.sdk.codebase.factory.get_session import get_codebase_session
+from codegen.sdk.core.dataclasses.usage import UsageType
+from codegen.shared.enums.programming_language import ProgrammingLanguage
+
+
+def test_namespace_same_file_usage(tmpdir) -> None:
+ """Test namespace usage within the same file."""
+ # language=typescript
+ content = """
+ namespace MathUtils {
+ export const PI = 3.14159;
+ export function square(x: number) { return x * x; }
+ }
+
+ function calculateArea(radius: number) {
+ return MathUtils.PI * MathUtils.square(radius);
+ }
+ """
+ with get_codebase_session(tmpdir=tmpdir, files={"test.ts": content}, programming_language=ProgrammingLanguage.TYPESCRIPT) as codebase:
+ file = codebase.get_file("test.ts")
+
+ namespace = file.get_symbol("MathUtils")
+ pi = namespace.get_symbol("PI")
+ square = namespace.get_symbol("square")
+ calc_area = file.get_function("calculateArea")
+
+ # Check if namespace is in valid_import_names
+ assert "MathUtils" in file.valid_symbol_names
+ assert "MathUtils" in namespace.valid_import_names
+ assert len(namespace.valid_import_names) == 3 # MathUtils, PI, and square
+
+ # Check usages
+ assert {calc_area}.issubset(namespace.symbol_usages)
+
+ # PI has direct usage (export) and chained usage (in calculateArea)
+ assert set(pi.symbol_usages(UsageType.DIRECT)) == {pi.export}
+ assert set(pi.symbol_usages(UsageType.CHAINED)) == {calc_area}
+ assert set(pi.symbol_usages) == {pi.export, calc_area}
+
+ # square has direct usage (export) and chained usage (in calculateArea)
+ assert set(square.symbol_usages(UsageType.DIRECT)) == {square.export}
+ assert set(square.symbol_usages(UsageType.CHAINED)) == {calc_area}
+ assert set(square.symbol_usages) == {square.export, calc_area}
+
+ # Verify attribute resolution
+ assert namespace.resolve_attribute("PI") == pi.export
+ assert namespace.resolve_attribute("square") == square.export
+
+
+def test_namespace_cross_file_usage(tmpdir) -> None:
+ """Test namespace usage across files with imports."""
+ # language=typescript
+ content1 = """
+ export namespace MathUtils {
+ export const PI = 3.14159;
+ export function square(x: number) { return x * x; }
+ const internal = 123; // not exported
+ }
+ """
+ # language=typescript
+ content2 = """
+ import { MathUtils } from './file1';
+
+ function calculateArea(radius: number) {
+ return MathUtils.PI * MathUtils.square(radius);
+ }
+
+ function calculateVolume(radius: number) {
+ const area = calculateArea(radius);
+ return area * radius;
+ }
+ """
+ with get_codebase_session(tmpdir=tmpdir, files={"file1.ts": content1, "file2.ts": content2}, programming_language=ProgrammingLanguage.TYPESCRIPT) as codebase:
+ file1 = codebase.get_file("file1.ts")
+ file2 = codebase.get_file("file2.ts")
+
+ # Get symbols
+ namespace = file1.get_symbol("MathUtils")
+ pi = namespace.get_symbol("PI")
+ square = namespace.get_symbol("square")
+ internal = namespace.get_symbol("internal")
+ calc_area = file2.get_function("calculateArea")
+ calc_volume = file2.get_function("calculateVolume")
+ namespace_import = file2.get_import("MathUtils")
+
+ # Check namespace visibility
+ assert "MathUtils" in namespace.valid_import_names
+ assert "PI" in namespace.valid_import_names
+ assert "square" in namespace.valid_import_names
+ assert "internal" not in namespace.valid_import_names
+ assert internal is None # private symbol not accessible
+
+ # Check direct vs chained usages
+ assert {namespace.export}.issubset(namespace.symbol_usages(UsageType.DIRECT))
+ assert {namespace.export, calc_area}.issubset(namespace.symbol_usages)
+ assert {pi.export}.issubset(pi.symbol_usages(UsageType.DIRECT))
+ assert {pi.export, calc_area}.issubset(pi.symbol_usages)
+ assert {calc_area}.issubset(square.symbol_usages(UsageType.CHAINED))
+
+ # Verify attribute resolution
+ assert namespace.resolve_attribute("PI") == pi.export
+ assert namespace.resolve_attribute("square") == square.export
+ assert namespace.resolve_attribute("internal") is None
diff --git a/tests/unit/codegen/sdk/typescript/tsx/test_tsx_edit.py b/tests/unit/codegen/sdk/typescript/tsx/test_tsx_edit.py
index 6f21af839..a7147bf3a 100644
--- a/tests/unit/codegen/sdk/typescript/tsx/test_tsx_edit.py
+++ b/tests/unit/codegen/sdk/typescript/tsx/test_tsx_edit.py
@@ -333,7 +333,7 @@ def test_tsx_move_component(tmpdir) -> None:
ctx.commit_transactions()
assert "export function FooBar" in new_file.content
- assert "export function MyFooBar" in new_file.content
+ assert "function MyFooBar" in new_file.content
assert "import { FooBar } from 'new'" in original_file.content
assert "import { MyFooBar } from 'new'" not in original_file.content
diff --git a/tests/unit/codegen/sdk/typescript/tsx/test_tsx_parsing.py b/tests/unit/codegen/sdk/typescript/tsx/test_tsx_parsing.py
index af2f32446..813102927 100644
--- a/tests/unit/codegen/sdk/typescript/tsx/test_tsx_parsing.py
+++ b/tests/unit/codegen/sdk/typescript/tsx/test_tsx_parsing.py
@@ -105,7 +105,7 @@ def test_tsx_file_type_validation(tmpdir) -> None:
test_component.move_to_file(tsx_file)
- assert "export function TestComponent" in tsx_file.content
+ assert "function TestComponent" in tsx_file.content
def test_jsx_element_attributes(tmpdir) -> None:
diff --git a/tests/unit/skills/implementations/guides/organize-your-codebase.py b/tests/unit/skills/implementations/guides/organize-your-codebase.py
index 5827d2ca5..d2e914bd2 100644
--- a/tests/unit/skills/implementations/guides/organize-your-codebase.py
+++ b/tests/unit/skills/implementations/guides/organize-your-codebase.py
@@ -416,7 +416,7 @@ def my_symbol():
SkillTestCaseTSFile(
input="",
output="""
-export function dependencyFunction() {
+function dependencyFunction() {
console.log("I'm a dependency");
}
-
-