def test_fetch_content_equals_file_content_from_nix_expression( network_file: NetworkFile, nix: Nix): fetch_content = network_file.fetch() nix_expression = "with builtins;" nix_expression += "let pkgs = import <nixpkgs> {};" nix_expression += f"fileContent = readFile ({network_file.nix_expression()});" nix_expression += " in " nix_expression += 'pkgs.writeTextFile { name = "test"; text = fileContent; }' with tempfile.TemporaryDirectory() as target_directory: target_file = os.path.join(target_directory, "result") nix.build_expression(nix_expression, out_link=target_file) with open(target_file) as f: nix_content = f.read() assert nix_content == fetch_content
def test_can_build_a_flake(tmpdir, nix: Nix): build_dir: Path = Path(str(tmpdir)) out_link_path = build_dir / "result" flake_path = build_dir / "flake.nix" flake_path.write_text( """{ description = "A flake for building Hello World"; inputs.nixpkgs.url = github:NixOS/nixpkgs/nixos-20.03; outputs = { self, nixpkgs }: { defaultPackage.x86_64-linux = nixpkgs.legacyPackages.x86_64-linux.hello; }; }""" ) nix.build_flake(flake_path / "..", out_link=out_link_path) completed_process = subprocess.run(str(out_link_path / "bin" / "hello")) assert completed_process.returncode == 0
def test_flake_with_packages_can_be_built( flake_renderer: FlakeRenderer, build_wheels, package_generator: PackageGenerator, generated_sources: Sources, result_path: Path, nix: Nix, flake_directory: Path, ) -> None: package_generator.generate_setuptools_package(name="package1") wheels = build_wheels(["package1"]) flake_renderer.render_expression( packages_metadata=wheels, sources=generated_sources, ) nix.build_flake(flake_directory, out_link=result_path) assert (result_path / "bin" / "python").exists()
def build_wheel(target_directory: Path, requirement: str) -> str: logger = StreamLogger(sys.stdout) requirement_parser = RequirementParser(logger=logger) package_directory: str = str(ROOT / "unittests" / "data") escaped_requirement = shlex.quote(requirement) target_directory = target_directory.resolve() with tempfile.TemporaryDirectory() as build_directory: os.chdir(str(build_directory)) nix = Nix(logger=logger) nix.shell( command= f"pip wheel {escaped_requirement} --find-links {str(package_directory)} --no-deps", derivation_path=DERIVATION_PATH, nix_arguments=dict(), ) try: parsed_requirement = requirement_parser.parse(requirement) except ParsingFailed: for path in os.listdir("."): if path.endswith(".whl"): wheel_path = path break else: raise Exception("Build process did not produce .whl file") else: for path in os.listdir("."): if path.endswith(".whl") and parsed_requirement.name() in path: wheel_path = path break else: raise Exception("Build process did not produce .whl file") target_file_name = os.path.basename(wheel_path) target_path = target_directory / target_file_name shutil.move(wheel_path, str(target_path)) return target_file_name
def nix(logger): return Nix(logger)
def nix(self) -> Nix: return Nix( nix_path=self.configuration.nix_path, executable_directory=self.configuration.nix_executable_directory, logger=self.logger(), )
def nix(logger: Logger) -> Nix: return Nix(logger)
def test_evaluate_nix_expression_raises_exception_when_executable_not_found( logger): nix = Nix(executable_directory="/does-not-exist", logger=logger) with pytest.raises(ExecutableNotFound): nix.evaluate_expression("true")
def nix_instance(tmpdir, logger): nix_path_addition = tmpdir.mkdir("testpath_exists") yield Nix(nix_path=["test_variable={}".format(str(nix_path_addition))], logger=logger)
def setUp(self) -> None: self.logger = StreamLogger(output=sys.stdout) self.nix = Nix(logger=self.logger) self.assertNotEqual(self.name_of_testcase, "undefined") self.requirement_parser = RequirementParser(self.logger)
class IntegrationTest(TestCase): """Methods to implement for a valid test case: name_of_testcase requirements optional: setup_requires() -- default: [] executables_for_testing() -- default: [] extra_environment() -- default: dict() external_dependencies requirements_file_check(content) -- default: (lambda content: None) constraints code_for_testing python_version code_for_testing_filename explicit_build_directory dependencyGraph -- default {}: yaml that will be used as input for pypi2nix check_dependency_graph( self, dependency_graph: DependencyGraph, requirement_parser: RequirementParser ): Override this function in your test case to perform checks on the dependency graph information that pypi2nix renders. You can use the requirement_parser supplied though the method argument to generate Requirement objects. For example:: django = requirement_parser.parse('django') pytz = requirement_parser.parse('pytz') If we wanted to check that pypi2nix detected the dependency of django on the pytz package than we could do it the following way: self.assertTrue( dependency_graph.is_runtime_dependency( dependent=django, dependency=pytz, ) ) """ def setUp(self) -> None: self.logger = StreamLogger(output=sys.stdout) self.nix = Nix(logger=self.logger) self.assertNotEqual(self.name_of_testcase, "undefined") self.requirement_parser = RequirementParser(self.logger) def test_build_example(self) -> None: self.build_pypi2nix() self.generate_requirements_file() self.build_nix_expression() self.check_requirements_file_content() self.run_expression_tests() self.run_dependency_graph_tests() def build_pypi2nix(self) -> None: print("Build pypi2nix executable") try: self.nix.build( os.path.join(os.path.dirname(HERE), "default.nix"), out_link=os.path.join(HERE, "pypi2nix"), ) except EvaluationFailed: self.fail("Could not build pypi2nix executable") def generate_requirements_file(self) -> None: print("Generate requirements.txt") requirements_file_content = self.generate_requirements_file_content() self.write_requirements_file(requirements_file_content) def build_nix_expression(self) -> None: print("Build nix expression") if self.explicit_build_directory: self.prepare_build_directory() process = subprocess.Popen( self.build_nix_expression_command(), cwd=self.example_directory(), env=self.nix_build_env(), stdin=subprocess.DEVNULL, ) process.communicate() if process.returncode != 0: self.fail("Could not build nix expression for {testname}".format( testname=self.name_of_testcase)) def build_nix_expression_command(self) -> List[str]: command = [ os.path.join(HERE, "pypi2nix", "bin", "pypi2nix"), "-vvv", "-V", self.python_version, "-r", "requirements.txt", "--default-overrides", "--dependency-graph-input", self.rendered_dependency_graph(), "--dependency-graph-output", self._dependency_graph_output_path(), ] for requirement in self.setup_requires(): command.append("-s") command.append(requirement) for variable_name, value in self.extra_environment().items(): command.append("-N") command.append("{name}={value}".format(name=variable_name, value=value)) for dependency in self.external_dependencies: command.append("-E") command.append(dependency) if self.explicit_build_directory: command.append("--build-directory") command.append(self.build_directory()) return command def setup_requires(self) -> List[str]: return [] def check_requirements_file_content(self) -> None: requirements_file_content = self.read_requirements_file_contents() self.requirements_file_check(requirements_file_content) def run_expression_tests(self) -> None: self.build_interpreter_from_generated_expression() self.build_additional_attributes() self.run_interpreter_with_test_code() self.run_executable_tests() def run_dependency_graph_tests(self) -> None: dependency_graph = self._read_dependency_graph() self.check_dependency_graph(dependency_graph, self.requirement_parser) def build_interpreter_from_generated_expression(self) -> None: print("Build python interpreter from generated expression") try: self.nix.build( os.path.join(self.example_directory(), "requirements.nix"), attribute="interpreter", out_link=os.path.join(self.example_directory(), "result"), ) except EvaluationFailed: self.fail( "Failed to build python interpreter from nix expression generated" ) def build_additional_attributes(self) -> None: for additional_path in self.additional_paths_to_build: try: self.nix.evaluate_file( os.path.join(self.example_directory(), "requirements.nix"), attribute=additional_path, ) except EvaluationFailed: self.fail(f"Failed to build attribute path {additional_path}") def run_interpreter_with_test_code(self) -> None: if self.code_for_testing_string(): test_code = self.code_for_testing_string() self.run_interpreter_with_test_code_from_result(test_code) self.run_interpreter_with_test_code_in_nix_shell(test_code) def run_interpreter_with_test_code_from_result(self, test_code: str) -> None: print("Run generated interpreter with test code") process = subprocess.Popen( [ os.path.join(self.example_directory(), "result", "bin", "python") ], stdin=subprocess.PIPE, ) process.communicate(input=test_code.encode()) if process.returncode != 0: self.fail("Executation of test code failed") def run_interpreter_with_test_code_in_nix_shell(self, test_code: str) -> None: print("Execute test code in nix-shell") test_command_line = [ "nix", "run", "--show-trace", "-f", os.path.join(self.example_directory(), "requirements.nix"), "interpreter", "--command", "python", ] process = subprocess.Popen( test_command_line, cwd=os.path.join(self.example_directory(), "result", "bin"), env=self.nix_build_env(), stdin=subprocess.PIPE, ) process.communicate(input=test_code.encode()) if process.returncode != 0: self.fail("Executation of test code in nix-shell failed") def read_requirements_file_contents(self) -> str: with open(os.path.join(self.example_directory(), "requirements.nix")) as f: return f.read() def code_for_testing_string(self) -> str: if self.code_for_testing and self.code_for_testing_filename: self.fail( "Cannot set `both code_for_testing` and `code_for_testing_filename`." ) if self.code_for_testing: return "\n".join(self.code_for_testing) elif self.code_for_testing_filename: with open( os.path.join(self.example_directory(), self.code_for_testing_filename)) as f: return f.read() else: return "" code_for_testing: List[str] = [] code_for_testing_filename: Optional[str] = None def extra_environment(self) -> Dict[str, str]: return dict() def run_executable_tests(self) -> None: for test_command in self.executables_for_testing(): self.run_test_command_in_shell(test_command) self.run_test_command_from_build_output(test_command) def run_test_command_in_shell(self, test_command: "TestCommand") -> None: print("Run {command} in nix-shell".format(command=test_command)) test_command_line = [ "nix", "run", "--show-trace", "-f", os.path.join(self.example_directory(), "requirements.nix"), "interpreter", "--command", ] + test_command.command process = subprocess.Popen( test_command_line, cwd=os.path.join(self.example_directory(), "result", "bin"), env=dict(self.nix_build_env(), **test_command.env), ) process.communicate() print() # for empty line after command output if process.returncode != 0: self.fail( "Tested executable `{command}` returned non-zero exitcode.". format(command=test_command)) def run_test_command_from_build_output( self, test_command: "TestCommand") -> None: prepared_test_command = evolve( test_command, command=["./" + test_command.command[0]] + test_command.command[1:], ) print("Run {command}".format(command=prepared_test_command)) process = subprocess.Popen( prepared_test_command.command, cwd=os.path.join(self.example_directory(), "result", "bin"), env=dict(self.nix_build_env(), **prepared_test_command.env), ) process.communicate() print() # for empty line after command output if process.returncode != 0: self.fail( "Tested executable `{command}` returned non-zero exitcode.". format(command=test_command)) def executables_for_testing(self) -> List["TestCommand"]: return [] def nix_build_env(self) -> Dict[str, str]: environment_variables = dict(os.environ) del environment_variables["PYTHONPATH"] return environment_variables def generate_requirements_file_content(self) -> str: if self.constraints: self.generate_constraints_txt() requirements_txt_extra_content = [ "-c " + self.constraints_txt_path() ] else: requirements_txt_extra_content = [] return "\n".join(self.requirements + requirements_txt_extra_content) def generate_constraints_txt(self) -> None: with open(self.constraints_txt_path(), "w") as f: f.write("\n".join(self.constraints)) def constraints_txt_path(self) -> str: return os.path.join(self.example_directory(), "constraints.txt") def write_requirements_file(self, content: str) -> None: os.makedirs(os.path.dirname(self.requirements_file_path()), exist_ok=True) with open(self.requirements_file_path(), "w") as f: f.write(content) def requirements_file_path(self) -> str: return os.path.join(self.example_directory(), "requirements.txt") def example_directory(self) -> str: return os.path.join(HERE, self.name_of_testcase) def requirements_file_check(self, _: str) -> None: pass def _dependency_graph_output_path(self) -> str: return os.path.join(self.example_directory(), "dependency-graph.yml") def build_directory(self): return os.path.join(self.example_directory(), "build") def prepare_build_directory(self): if os.path.exists(self.build_directory()): shutil.rmtree(self.build_directory()) os.makedirs(self.build_directory()) def check_dependency_graph(self, dependency_graph: DependencyGraph, requirement_parser: RequirementParser): pass def _read_dependency_graph(self) -> DependencyGraph: with open(self._dependency_graph_output_path()) as f: return DependencyGraph.deserialize(f.read()) constraints: List[str] = [] python_version: str = "python3" requirements: List[str] = [] name_of_testcase: str = "undefined" external_dependencies: List[str] = [] explicit_build_directory: bool = False additional_paths_to_build: List[str] = [] dependency_graph: Dict[str, Dict[str, List[str]]] = {} @memoize def rendered_dependency_graph(self) -> str: path = os.path.join(self.example_directory(), "dependency-input.yml") with open(path, "w") as f: yaml.dump( self.dependency_graph, f, ) return path
def main( version: str, verbose: int, nix_shell: str, nix_path: List[str], basename: str, cache_dir: str, extra_build_inputs: List[str], extra_env: str, enable_tests: bool, python_version: str, requirements: List[str], editable: List[str], setup_requires: List[str], overrides: List[AnyOverrides], default_overrides: bool, wheels_cache: List[str], ) -> None: """SPECIFICATION should be requirements.txt (output of pip freeze). """ logger = Logger(output=sys.stdout) nix_executable_directory: Optional[str] = (os.path.abspath( os.path.dirname(nix_shell)) if os.path.exists(nix_shell) else None) nix = Nix( nix_path=nix_path, executable_directory=nix_executable_directory, verbose=verbose != 0, ) platform_generator = PlatformGenerator(nix=nix) if default_overrides: overrides += tuple([ pypi2nix.overrides.OverridesGithub(owner="garbas", repo="nixpkgs-python", path="overrides.nix") ]) with open(os.path.join(os.path.dirname(__file__), "VERSION")) as f: pypi2nix_version = f.read() if version: click.echo(pypi2nix_version) return python_version_argument = python_version python_versions = pypi2nix.utils.PYTHON_VERSIONS.keys() if not python_version: raise click.exceptions.UsageError( 'Missing option "-V" / "--python-version". Choose from ' + (", ".join(python_versions))) python_version = pypi2nix.utils.PYTHON_VERSIONS[python_version] target_platform = platform_generator.from_python_version( python_version_argument) requirement_collector = RequirementsCollector(target_platform) setup_requirement_collector = RequirementsCollector(target_platform) extra_build_inputs = pypi2nix.utils.args_as_list(extra_build_inputs) setup_requires = pypi2nix.utils.args_as_list(setup_requires) for item in editable: requirement_collector.add_line(item) for build_input in setup_requires: setup_requirement_collector.add_line(build_input) # temporary pypi2nix folder and make sure it exists tmp_dir = os.path.join(tempfile.gettempdir(), "pypi2nix") if not os.path.exists(tmp_dir): os.makedirs(tmp_dir) current_dir = os.getcwd() requirements_name = os.path.join(current_dir, basename) if not cache_dir: cache_dir = os.path.join(tmp_dir, "cache") download_cache_dir = os.path.join(cache_dir, "download") wheel_cache_dir = os.path.join(cache_dir, "wheel") if not os.path.exists(download_cache_dir): os.makedirs(download_cache_dir) if not os.path.exists(wheel_cache_dir): os.makedirs(wheel_cache_dir) assert requirements is not None project_hash = md5_sum_of_files_with_file_names(requirements) project_dir = os.path.join(tmp_dir, project_hash) if os.path.exists(project_dir): shutil.rmtree(project_dir) os.makedirs(project_dir) for requirement_file_path in requirements: requirement_collector.add_file(requirement_file_path) requirement_set = requirement_collector.requirements() setup_requirements = setup_requirement_collector.requirements() sources = Sources() sources.update(requirement_set.sources()) sources.update(setup_requirements.sources()) click.echo("pypi2nix v{} running ...".format(pypi2nix_version)) click.echo("") click.echo("Stage1: Downloading wheels and creating wheelhouse ...") pip = Pip( nix=nix, project_directory=project_dir, extra_env=extra_env, extra_build_inputs=extra_build_inputs, verbose=verbose, wheels_cache=wheels_cache, target_platform=target_platform, ) wheel_builder = pypi2nix.stage1.WheelBuilder(pip=pip, project_directory=project_dir, logger=logger) wheels = wheel_builder.build(requirements=requirement_set, setup_requirements=setup_requirements) requirements_frozen = wheel_builder.get_frozen_requirements() default_environment = pip.default_environment() additional_dependency_graph = wheel_builder.additional_build_dependencies click.echo("Stage2: Extracting metadata from pypi.python.org ...") stage2 = pypi2nix.stage2.Stage2(sources=sources, verbose=verbose) packages_metadata = stage2.main( wheel_paths=wheels, default_environment=default_environment, wheel_cache_dir=wheel_cache_dir, additional_dependencies=additional_dependency_graph, ) click.echo("Stage3: Generating Nix expressions ...") pypi2nix.stage3.main( packages_metadata=packages_metadata, sources=sources, requirements_name=requirements_name, requirements_frozen=requirements_frozen, extra_build_inputs=extra_build_inputs, enable_tests=enable_tests, python_version=python_version, current_dir=current_dir, common_overrides=overrides, ) click.echo("") click.echo("Nix expressions generated successfully.") click.echo("") click.echo("To start development run:") click.echo(" nix-shell requirements.nix -A interpreter") click.echo("") click.echo("More information you can find at") click.echo(" https://github.com/garbas/pypi2nix") click.echo("")
def nix(): return Nix(verbose=True)
def expression_evaluater(nix: Nix): return lambda expression: nix.evaluate_expression( "let pkgs = import <nixpkgs> {}; in " + expression)
def expression_evaluater(logger): nix_instance = Nix(logger=logger) return lambda expression: nix_instance.evaluate_expression( "let pkgs = import <nixpkgs> {}; in " + expression )
class IntegrationTest(TestCase): """Methods to implement for a valid test case: name_of_testcase requirements optional: setup_requires() -- default: [] executables_for_testing() -- default: [] extra_environment() -- default: dict() external_dependencies requirements_file_check(content) -- default: (lambda content: None) constraints code_for_testing python_version default_overrides code_for_testing_filename explicit_build_directory """ def setUp(self) -> None: self.logger = StreamLogger(output=sys.stdout) self.nix = Nix(nix_path=[NIX_PATH], logger=self.logger) self.assertNotEqual(self.name_of_testcase, "undefined") def test_build_example(self) -> None: self.build_pypi2nix() self.generate_requirements_file() self.build_nix_expression() self.check_requirements_file_content() self.run_expression_tests() def build_pypi2nix(self) -> None: print("Build pypi2nix executable") try: self.nix.build( os.path.join(os.path.dirname(HERE), "default.nix"), out_link=os.path.join(HERE, "pypi2nix"), ) except EvaluationFailed: self.fail("Could not build pypi2nix executable") def generate_requirements_file(self) -> None: print("Generate requirements.txt") requirements_file_content = self.generate_requirements_file_content() self.write_requirements_file(requirements_file_content) def build_nix_expression(self) -> None: print("Build nix expression") if self.explicit_build_directory: self.prepare_build_directory() process = subprocess.Popen( self.build_nix_expression_command(), cwd=self.example_directory(), env=self.nix_build_env(), stdin=subprocess.DEVNULL, ) process.communicate() if process.returncode != 0: self.fail("Could not build nix expression for {testname}".format( testname=self.name_of_testcase)) def build_nix_expression_command(self) -> List[str]: command = [ os.path.join(HERE, "pypi2nix", "bin", "pypi2nix"), "-vvv", "-V", self.python_version, "-r", "requirements.txt", ] for requirement in self.setup_requires(): command.append("-s") command.append(requirement) for variable_name, value in self.extra_environment().items(): command.append("-N") command.append("{name}={value}".format(name=variable_name, value=value)) for dependency in self.external_dependencies: command.append("-E") command.append(dependency) if self.explicit_build_directory: command.append("--build-directory") command.append(self.build_directory()) if self.default_overrides: command.append("--default-overrides") return command def setup_requires(self) -> List[str]: return [] def check_requirements_file_content(self) -> None: requirements_file_content = self.read_requirements_file_contents() self.requirements_file_check(requirements_file_content) def run_expression_tests(self) -> None: self.build_interpreter_from_generated_expression() self.run_interpreter_with_test_code() self.run_executable_tests() def build_interpreter_from_generated_expression(self) -> None: print("Build python interpreter from generated expression") try: self.nix.build( os.path.join(self.example_directory(), "requirements.nix"), attribute="interpreter", out_link=os.path.join(self.example_directory(), "result"), ) except EvaluationFailed: self.fail( "Failed to build python interpreter from nix expression generated" ) def run_interpreter_with_test_code(self) -> None: if self.code_for_testing_string(): test_code = self.code_for_testing_string() self.run_interpreter_with_test_code_from_result(test_code) self.run_interpreter_with_test_code_in_nix_shell(test_code) def run_interpreter_with_test_code_from_result(self, test_code: str) -> None: print("Run generated interpreter with test code") process = subprocess.Popen( [ os.path.join(self.example_directory(), "result", "bin", "python") ], stdin=subprocess.PIPE, ) process.communicate(input=test_code.encode()) if process.returncode != 0: self.fail("Executation of test code failed") def run_interpreter_with_test_code_in_nix_shell(self, test_code: str) -> None: print("Execute test code in nix-shell") test_command_line = [ "nix", "run", "--show-trace", "-f", os.path.join(self.example_directory(), "requirements.nix"), "interpreter", "--command", "python", ] process = subprocess.Popen( test_command_line, cwd=os.path.join(self.example_directory(), "result", "bin"), env=self.nix_build_env(), stdin=subprocess.PIPE, ) process.communicate(input=test_code.encode()) if process.returncode != 0: self.fail("Executation of test code in nix-shell failed") def read_requirements_file_contents(self) -> str: with open(os.path.join(self.example_directory(), "requirements.nix")) as f: return f.read() def code_for_testing_string(self) -> str: if self.code_for_testing and self.code_for_testing_filename: self.fail( "Cannot set `both code_for_testing` and `code_for_testing_filename`." ) if self.code_for_testing: return "\n".join(self.code_for_testing) elif self.code_for_testing_filename: with open( os.path.join(self.example_directory(), self.code_for_testing_filename)) as f: return f.read() else: return "" code_for_testing: List[str] = [] code_for_testing_filename: Optional[str] = None def extra_environment(self) -> Dict[str, str]: return dict() def run_executable_tests(self) -> None: for test_command in self.executables_for_testing(): self.run_test_command_in_shell(test_command) self.run_test_command_from_build_output(test_command) def run_test_command_in_shell(self, test_command: "TestCommand") -> None: print("Run {command} in nix-shell".format(command=test_command)) test_command_line = [ "nix", "run", "--show-trace", "-f", os.path.join(self.example_directory(), "requirements.nix"), "interpreter", "--command", ] + test_command.command process = subprocess.Popen( test_command_line, cwd=os.path.join(self.example_directory(), "result", "bin"), env=dict(self.nix_build_env(), **test_command.env), ) process.communicate() print() # for empty line after command output if process.returncode != 0: self.fail( "Tested executable `{command}` returned non-zero exitcode.". format(command=test_command)) def run_test_command_from_build_output( self, test_command: "TestCommand") -> None: prepared_test_command = evolve( test_command, command=["./" + test_command.command[0]] + test_command.command[1:], ) print("Run {command}".format(command=prepared_test_command)) process = subprocess.Popen( prepared_test_command.command, cwd=os.path.join(self.example_directory(), "result", "bin"), env=dict(self.nix_build_env(), **prepared_test_command.env), ) process.communicate() print() # for empty line after command output if process.returncode != 0: self.fail( "Tested executable `{command}` returned non-zero exitcode.". format(command=test_command)) def executables_for_testing(self) -> List["TestCommand"]: return [] def nix_build_env(self) -> Dict[str, str]: environment_variables = dict(os.environ) environment_variables["NIX_PATH"] = NIX_PATH del environment_variables["PYTHONPATH"] return environment_variables def generate_requirements_file_content(self) -> str: if self.constraints: self.generate_constraints_txt() requirements_txt_extra_content = [ "-c " + self.constraints_txt_path() ] else: requirements_txt_extra_content = [] return "\n".join(self.requirements + requirements_txt_extra_content) def generate_constraints_txt(self) -> None: with open(self.constraints_txt_path(), "w") as f: f.write("\n".join(self.constraints)) def constraints_txt_path(self) -> str: return os.path.join(self.example_directory(), "constraints.txt") def write_requirements_file(self, content: str) -> None: os.makedirs(os.path.dirname(self.requirements_file_path()), exist_ok=True) with open(self.requirements_file_path(), "w") as f: f.write(content) def requirements_file_path(self) -> str: return os.path.join(self.example_directory(), "requirements.txt") def example_directory(self) -> str: return os.path.join(HERE, self.name_of_testcase) def requirements_file_check(self, _: str) -> None: pass def build_directory(self): return os.path.join(self.example_directory(), "build") def prepare_build_directory(self): if os.path.exists(self.build_directory()): shutil.rmtree(self.build_directory()) os.makedirs(self.build_directory()) default_overrides = False constraints: List[str] = [] python_version: str = "python3" requirements: List[str] = [] name_of_testcase: str = "undefined" external_dependencies: List[str] = [] explicit_build_directory: bool = False
def setUp(self) -> None: self.logger = StreamLogger(output=sys.stdout) self.nix = Nix(nix_path=[NIX_PATH], logger=self.logger) self.assertNotEqual(self.name_of_testcase, "undefined")
def test_can_evaluate_nix_expression(network_file: NetworkFile, nix: Nix): expression = f"let pkgs = import <nixpkgs> {{}}; in {network_file.nix_expression()}" nix.evaluate_expression(expression)