def test_get_csharp_libraries_skips_invalid_package_reference_tags() -> None:
create_fake_lean_cli_directory()
with (Path.cwd() / "CSharp Project" / "CSharp Project.csproj").open("w+", encoding="utf-8") as file:
file.write("""
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<TargetFramework>net5.0</TargetFramework>
<LangVersion>9</LangVersion>
<OutputPath>bin/$(Configuration)</OutputPath>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<NoWarn>CS0618</NoWarn>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="QuantConnect.Lean" Version="2.5.11586"/>
<PackageReference Include="Microsoft.ML"/>
<PackageReference Version="0.94.0"/>
<PackageReference/>
</ItemGroup>
</Project>
""")
project_config_manager = ProjectConfigManager(XMLManager())
libraries = project_config_manager.get_csharp_libraries(Path.cwd() / "CSharp Project")
assert len(libraries) == 1
assert CSharpLibrary(name="QuantConnect.Lean", version="2.5.11586") in libraries
def test_get_project_config_returns_storage_instance_of_correct_file() -> None:
create_fake_lean_cli_directory()
project_config_manager = ProjectConfigManager(XMLManager())
project_config = project_config_manager.get_project_config(Path.cwd() / "Python Project")
assert project_config.file == Path.cwd() / "Python Project" / "config.json"
def test_get_local_id_returns_unique_id_per_project() -> None:
create_fake_lean_cli_directory()
project_config_manager = ProjectConfigManager(XMLManager())
python_id = project_config_manager.get_local_id(Path.cwd() / "Python Project")
csharp_id = project_config_manager.get_local_id(Path.cwd() / "CSharp Project")
assert python_id != csharp_id
def test_get_local_id_returns_same_id_for_project_when_called_multiple_times() -> None:
create_fake_lean_cli_directory()
project_config_manager = ProjectConfigManager(XMLManager())
ids = []
for _ in range(5):
ids.append(project_config_manager.get_local_id(Path.cwd() / "Python Project"))
assert len(set(ids)) == 1
def test_get_project_by_id_returns_path_to_project() -> None:
create_fake_lean_cli_directory()
project_dir = Path.cwd() / "Python Project"
project_config_manager = ProjectConfigManager(XMLManager())
project_id = project_config_manager.get_local_id(project_dir)
project_manager = _create_project_manager()
assert project_manager.get_project_by_id(project_id) == project_dir
def test_get_project_by_id_raises_error_when_no_project_with_given_id_exists(
) -> None:
create_fake_lean_cli_directory()
project_config_manager = ProjectConfigManager(XMLManager())
python_project_id = project_config_manager.get_local_id(Path.cwd() /
"Python Project")
csharp_project_id = project_config_manager.get_local_id(Path.cwd() /
"CSharp Project")
project_manager = _create_project_manager()
with pytest.raises(Exception):
project_manager.get_project_by_id(
max(python_project_id, csharp_project_id) + 1)
def test_create_new_project_copies_ssh_keys_to_global_config_dir() -> None:
project_manager = ProjectManager(ProjectConfigManager())
project_manager.create_new_project(Path.cwd() / "CSharp Project",
QCLanguage.CSharp)
for name in ["key", "key.pub", "README.md"]:
assert Path(f"~/.lean/ssh/{name}").expanduser().is_file()
def test_create_new_project_creates_project_directory() -> None:
project_path = Path.cwd() / "Python Project"
project_manager = ProjectManager(ProjectConfigManager())
project_manager.create_new_project(project_path, QCLanguage.Python)
assert project_path.is_dir()
def test_create_new_project_does_not_update_pycharm_jdk_table_when_jdk_entry_already_set(
system: mock.Mock, editor: str, os: str, path: str) -> None:
system.return_value = os
jdk_table = """
<application>
<component name="ProjectJdkTable">
<jdk version="2">
<name value="Lean CLI" />
</jdk>
</component>
</application>
"""
jdk_table_file = Path(
path).expanduser() / f"{editor}2020.3" / "options" / "jdk.table.xml"
jdk_table_file.parent.mkdir(parents=True, exist_ok=True)
with jdk_table_file.open("w+", encoding="utf-8") as file:
file.write(jdk_table)
project_manager = ProjectManager(ProjectConfigManager())
project_manager.create_new_project(Path.cwd() / "Python Project",
QCLanguage.Python)
assert jdk_table_file.read_text(encoding="utf-8") == jdk_table
def create_lean_runner(docker_manager: mock.Mock) -> LeanRunner:
logger = mock.Mock()
logger.debug_logging_enabled = False
cli_config_manager = mock.Mock()
cli_config_manager.user_id.get_value.return_value = "123"
cli_config_manager.api_token.get_value.return_value = "456"
project_config_manager = ProjectConfigManager(XMLManager())
cache_storage = Storage(str(Path("~/.lean/cache").expanduser()))
lean_config_manager = LeanConfigManager(logger, cli_config_manager,
project_config_manager,
mock.Mock(), cache_storage)
output_config_manager = OutputConfigManager(lean_config_manager)
module_manager = mock.Mock()
module_manager.get_installed_packages.return_value = [
NuGetPackage(name="QuantConnect.Brokerages", version="1.0.0")
]
xml_manager = XMLManager()
project_manager = ProjectManager(project_config_manager,
lean_config_manager, xml_manager,
PlatformManager())
return LeanRunner(logger, project_config_manager, lean_config_manager,
output_config_manager, docker_manager, module_manager,
project_manager, TempManager(), xml_manager)
def test_get_cli_root_directory_returns_path_to_directory_containing_config_file(
) -> None:
create_fake_lean_cli_directory()
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
assert manager.get_cli_root_directory() == Path.cwd()
def test_find_algorithm_file_returns_main_cs_when_input_directory_contains_it(
) -> None:
create_fake_lean_cli_directory()
project_manager = ProjectManager(ProjectConfigManager())
result = project_manager.find_algorithm_file(Path.cwd() / "CSharp Project")
assert result == Path.cwd() / "CSharp Project" / "Main.cs"
def test_find_algorithm_file_returns_input_when_input_is_file() -> None:
create_fake_lean_cli_directory()
project_manager = ProjectManager(ProjectConfigManager())
result = project_manager.find_algorithm_file(Path.cwd() /
"Python Project" / "main.py")
assert result == Path.cwd() / "Python Project" / "main.py"
def test_get_complete_lean_config_sets_close_automatically() -> None:
create_fake_lean_cli_directory()
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
config = manager.get_complete_lean_config(
"my-environment",
Path.cwd() / "Python Project" / "main.py", None)
assert config["close-automatically"]
def test_get_data_directory_returns_path_to_data_directory_as_configured_in_config(
) -> None:
with (Path.cwd() / "lean.json").open("w+", encoding="utf-8") as file:
file.write('{ "data-folder": "sub1/sub2/sub3/data" }')
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
assert manager.get_data_directory(
) == Path.cwd() / "sub1" / "sub2" / "sub3" / "data"
def test_get_complete_lean_config_sets_iqfeed_host() -> None:
create_fake_lean_cli_directory()
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
config = manager.get_complete_lean_config(
"my-environment",
Path.cwd() / "Python Project" / "main.py", None)
assert config["iqfeed-host"] == "host.docker.internal"
def test_create_new_project_sets_description_in_project_config() -> None:
project_path = Path.cwd() / "Python Project"
project_manager = ProjectManager(ProjectConfigManager())
project_manager.create_new_project(project_path, QCLanguage.Python)
config = Storage(str(project_path / "config.json"))
assert config.get("description") == ""
def _create_project_manager() -> ProjectManager:
xml_manager = XMLManager()
project_config_manager = ProjectConfigManager(xml_manager)
cache_storage = Storage(str(Path("~/.lean/cache").expanduser()))
return ProjectManager(
project_config_manager,
LeanConfigManager(mock.Mock(), mock.Mock(), project_config_manager,
mock.Mock(), cache_storage), xml_manager,
PlatformManager())
def test_create_new_project_sets_language_in_project_config(
language: QCLanguage) -> None:
project_path = Path.cwd() / f"{language.name} Project"
project_manager = ProjectManager(ProjectConfigManager())
project_manager.create_new_project(project_path, language)
config = Storage(str(project_path / "config.json"))
assert config.get("algorithm-language") == language.name
def test_find_algorithm_file_raises_error_when_no_algorithm_file_exists(
) -> None:
create_fake_lean_cli_directory()
(Path.cwd() / "Empty Project").mkdir()
project_manager = ProjectManager(ProjectConfigManager())
with pytest.raises(Exception):
project_manager.find_algorithm_file(Path.cwd() / "Empty Project")
def create_lean_runner(docker_manager: mock.Mock, csharp_compiler: mock.Mock = create_csharp_compiler()) -> LeanRunner:
cli_config_manager = mock.Mock()
cli_config_manager.user_id.get_value.return_value = "123"
cli_config_manager.api_token.get_value.return_value = "456"
return LeanRunner(mock.Mock(),
csharp_compiler,
LeanConfigManager(cli_config_manager, ProjectConfigManager()),
docker_manager,
TempManager())
def test_get_complete_lean_config_disables_debugging_when_no_method_given(
) -> None:
create_fake_lean_cli_directory()
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
config = manager.get_complete_lean_config(
"my-environment",
Path.cwd() / "Python Project" / "main.py", None)
assert not config["debugging"]
def test_get_complete_lean_config_sets_python_algorithm_details() -> None:
create_fake_lean_cli_directory()
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
config = manager.get_complete_lean_config(
"my-environment",
Path.cwd() / "Python Project" / "main.py", None)
assert config["algorithm-type-name"] == "main"
assert config["algorithm-language"] == "Python"
assert config["algorithm-location"] == "/LeanCLI/main.py"
def test_create_new_project_creates_valid_csharp_editor_configs(
file: str, validator: Callable[[str], bool]) -> None:
project_path = Path.cwd() / "CSharp Project"
project_manager = ProjectManager(ProjectConfigManager())
project_manager.create_new_project(project_path, QCLanguage.CSharp)
assert (project_path / file).is_file()
with open(project_path / file) as f:
assert validator(f.read())
def test_get_complete_lean_config_parses_debugging_method_correctly(
method: DebuggingMethod, value: str) -> None:
create_fake_lean_cli_directory()
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
config = manager.get_complete_lean_config(
"my-environment",
Path.cwd() / "Python Project" / "main.py", method)
assert config["debugging"]
assert config["debugging-method"] == value
def test_get_lean_config_path_returns_closest_config_file() -> None:
lean_config_path = Path.cwd() / "lean.json"
cwd_path = Path.cwd() / "sub1" / "sub2" / "sub3"
lean_config_path.touch()
cwd_path.mkdir(parents=True)
os.chdir(cwd_path)
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
assert manager.get_lean_config_path() == lean_config_path
def test_get_complete_lean_config_sets_interactive_brokers_config() -> None:
create_fake_lean_cli_directory()
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
config = manager.get_complete_lean_config(
"my-environment",
Path.cwd() / "Python Project" / "main.py", None)
assert config["ib-host"] == "127.0.0.1"
assert config["ib-port"] == "4002"
assert config["ib-tws-dir"] == "/root/Jts"
assert config["ib-version"] == "978"
def test_update_last_modified_time_updates_file_properties() -> None:
local_file = Path.cwd() / "file.txt"
local_file.touch()
new_timestamp = datetime(2020, 1, 1, 1, 1, 1)
project_manager = ProjectManager(ProjectConfigManager())
project_manager.update_last_modified_time(local_file, new_timestamp)
timestamp = local_file.stat().st_mtime_ns / 1e9
timestamp = datetime.fromtimestamp(timestamp)
assert timestamp.astimezone(tz=timezone.utc).replace(
tzinfo=None) == new_timestamp
def test_get_data_directory_returns_path_to_data_directory_when_config_contains_comments(
) -> None:
with (Path.cwd() / "lean.json").open("w+", encoding="utf-8") as file:
file.write("""
{
// some comment about the data-folder
"data-folder": "sub1/sub2/sub3/data"
}
""")
manager = LeanConfigManager(mock.Mock(), ProjectConfigManager())
assert manager.get_data_directory(
) == Path.cwd() / "sub1" / "sub2" / "sub3" / "data"
def test_get_files_to_sync_ignores_generated_source_files(
directory: str) -> None:
project_path = Path.cwd() / "My Project"
project_path.mkdir()
files = [project_path / "main.py", project_path / directory / "main.py"]
for file in files:
file.mkdir(parents=True, exist_ok=True)
file.touch()
project_manager = ProjectManager(ProjectConfigManager())
files_to_sync = project_manager.get_files_to_sync(project_path)
assert files_to_sync == [files[0]]
