Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:56
📄 __init__.py	0 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 conftest.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Example for a custom pytest fixture with an argument to Patcher. # Use this as a template if you want to write your own pytest plugin # with specific Patcher arguments. # See `pytest_plugin.py` for more information. import pytest from pyfakefs.fake_filesystem_unittest import Patcher # import the fs fixture to be visible if pyfakefs is not installed from pyfakefs.pytest_plugin import fs, fs_module # noqa: F401 from pyfakefs.pytest_tests import example # noqa: E402 @pytest.fixture def fs_reload_example(): """Fake filesystem.""" patcher = Patcher(modules_to_reload=[example]) patcher.setUp() yield patcher.fs patcher.tearDown() @pytest.fixture def fake_filesystem(fs): # noqa: F811 """Shows how to use an alias for the fs fixture.""" yield fs	1.3 KB	2026-01-20 12:58
📁 data	-	2026-03-21 15:45
📄 example.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Used as SUT for pytest_fixture_test.py from pathlib import Path EXAMPLE_FILE = Path("/test") / "file"	652 B	2026-01-20 12:58
📄 fake_fcntl_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import sys if sys.platform == "linux": import fcntl def test_unpatched_attributes_are_forwarded_to_real_fs(fs): # regression test for #1074 with open("lock_file", "a+") as lock_file: fcntl.flock(lock_file, fcntl.LOCK_SH) fcntl.flock(lock_file, fcntl.LOCK_UN)	855 B	2026-01-20 12:58
📁 hook_test	-	2026-03-21 15:45
📄 io.py """ This is a test case for pyfakefs issue #708. It tests the usage of an own module with the same name as a patched filesystem module, the content is taken from the issue. """ class InputStream: def __init__(self, name): self.name = name def read(self): with open(self.name) as f: return f.readline()	341 B	2026-01-20 12:58
📄 lib_using_pathlib.py import pathlib def use_pathlib(path: str): return pathlib.Path(path)	75 B	2026-01-20 12:58
📄 local_import.py def load(path: str) -> str: from pyfakefs.pytest_tests import lib_using_pathlib return lib_using_pathlib.use_pathlib(path)	132 B	2026-01-20 12:58
📁 ns_package	-	2026-03-21 15:45
📄 pytest_check_failed_plugin_test.py """Tests that a failed pytest properly displays the call stack. Uses the output from running pytest with pytest_plugin_failing_helper.py. Regression test for #381. """ import os import pytest @pytest.mark.skipif(not os.path.exists("testresult.txt"), reason="Only run in CI tests") def test_failed_testresult_stacktrace(): with open("testresult.txt") as f: contents = f.read() # before the fix, a triple question mark has been displayed # instead of the stacktrace assert contents print("contents", contents) assert "???" not in contents assert "AttributeError" not in contents assert "def test_fs(fs):" in contents	659 B	2026-01-20 12:58
📄 pytest_doctest_test.py """ This is a test case for pyfakefs issue #45. This problem is resolved by using PyTest version 2.8.6 or above. To run these doctests, install pytest and run: $ pytest --doctest-modules pytest_doctest_test.py Add `-s` option to enable print statements. """ def make_file_factory(func_name, fake, result): """Return a simple function with parametrized doctest.""" def make_file(name, content=""): with open(name, "w") as f: f.write(content) make_file.__doc__ = """ >>> import os >>> {command} >>> name, content = 'foo', 'bar' >>> {func_name}(name, content) >>> open(name).read() == content {result} >>> os.remove(name) # Cleanup """.format( command="getfixture('fs')" if fake else "pass", func_name=func_name, result=result, ) return make_file passes = make_file_factory("passes", fake=False, result=True) passes_too = make_file_factory("passes_too", fake=True, result=True) passes_too.__doc__ = passes_too.__doc__.replace(">>> os.remove(name)", ">>> pass") fails = make_file_factory("fails", fake=False, result=False) # Pytest versions below 2.8.6 raise an internal error when running # these doctests: crashes = make_file_factory("crashes", fake=True, result=False) crashes_too = make_file_factory(") SyntaxError", fake=True, result=False)	1.36 KB	2026-01-20 12:58
📄 pytest_fixture_param_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Example for a test using a custom pytest fixture with an argument to Patcher import os import pytest import pyfakefs.pytest_tests.example as example @pytest.mark.xfail def test_example_file_failing(fs): """Test fails because EXAMPLE_FILE is cached in the module and not patched.""" fs.create_file(example.EXAMPLE_FILE, contents="stuff here") check_that_example_file_is_in_fake_fs() @pytest.mark.parametrize("fs", [[None, [example]]], indirect=True) def test_example_file_passing_using_parametrized_fixture(fs): """Test passes if using a fixture that reloads the module containing EXAMPLE_FILE""" fs.create_file(example.EXAMPLE_FILE, contents="stuff here") check_that_example_file_is_in_fake_fs() def check_that_example_file_is_in_fake_fs(): with open(example.EXAMPLE_FILE) as file: assert file.read() == "stuff here" with example.EXAMPLE_FILE.open() as file: assert file.read() == "stuff here" assert example.EXAMPLE_FILE.read_text() == "stuff here" assert example.EXAMPLE_FILE.is_file() def test_twice_chdir(fs): # regression test for #530 - make sure that # alternative path separators are correctly handled under Windows fs.create_dir("/absolute/path/to/directory") os.chdir("/absolute/path/to/directory") os.chdir("/absolute/path/to/directory")	1.85 KB	2026-01-20 12:58
📄 pytest_fixture_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import pathlib import sys # Example for a test using a custom pytest fixture with an argument to Patcher import pytest import pyfakefs.pytest_tests.example as example from pyfakefs.fake_filesystem_unittest import Patcher from pyfakefs.pytest_tests import unhashable @pytest.mark.xfail def test_example_file_failing(fs): """Test fails because EXAMPLE_FILE is cached in the module and not patched.""" fs.create_file(example.EXAMPLE_FILE, contents="stuff here") check_that_example_file_is_in_fake_fs() def test_example_file_passing_using_fixture(fs_reload_example): """Test passes if using a fixture that reloads the module containing EXAMPLE_FILE""" fs_reload_example.create_file(example.EXAMPLE_FILE, contents="stuff here") check_that_example_file_is_in_fake_fs() def test_example_file_passing_using_patcher(): """Test passes if using a Patcher instance that reloads the module containing EXAMPLE_FILE""" with Patcher(modules_to_reload=[example]) as patcher: patcher.fs.create_file(example.EXAMPLE_FILE, contents="stuff here") check_that_example_file_is_in_fake_fs() def test_unhashable(fs): # regression test for #923 print(unhashable) def check_that_example_file_is_in_fake_fs(): with open(example.EXAMPLE_FILE) as file: assert file.read() == "stuff here" with example.EXAMPLE_FILE.open() as file: assert file.read() == "stuff here" assert example.EXAMPLE_FILE.read_text() == "stuff here" assert example.EXAMPLE_FILE.is_file() pytest_parent_path = pathlib.Path(pytest.__file__).parent.parent @pytest.mark.skipif( sys.version_info < (3, 8), reason="importlib.metadata not available" ) def test_add_package_metadata(fs): pytest_dist_path = pytest_parent_path / f"pytest-{pytest.__version__}.dist-info" assert not fs.exists(pytest_dist_path) fs.add_package_metadata("pytest") assert fs.exists(pytest_dist_path) assert fs.exists(pytest_dist_path / "METADATA")	2.48 KB	2026-01-20 12:58
📄 pytest_module_fixture_test.py # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import pytest @pytest.fixture(scope="module", autouse=True) def use_fs(fs_module): fs_module.create_file(os.path.join("foo", "bar")) yield fs_module @pytest.mark.usefixtures("fs") def test_fs_uses_fs_module1(): # check that `fs` uses the same filesystem as `fs_module` assert os.path.exists(os.path.join("foo", "bar")) def test_fs_uses_fs_module2(fs): # check that patching was not stopped by the first test assert os.path.exists(os.path.join("foo", "bar"))	1.02 KB	2026-01-20 12:58
📄 pytest_plugin_failing_helper.py """Failing test to test stacktrace output - see ``pytest_check_failed_plugin_test.py``.""" def test_fs(fs): assert 1 == 2	128 B	2026-01-20 12:58
📄 pytest_plugin_test.py """Tests that the pytest plugin properly provides the "fs" fixture""" import os import tempfile from pyfakefs.fake_filesystem import OSType from pyfakefs.fake_filesystem_unittest import Pause import pyfakefs.pytest_tests.io def test_fs_fixture(fs): fs.create_file("/var/data/xx1.txt") assert os.path.exists("/var/data/xx1.txt") def test_fs_fixture_alias(fake_filesystem): fake_filesystem.create_file("/var/data/xx1.txt") assert os.path.exists("/var/data/xx1.txt") def test_both_fixtures(fs, fake_filesystem): fake_filesystem.create_file("/var/data/xx1.txt") fs.create_file("/var/data/xx2.txt") assert os.path.exists("/var/data/xx1.txt") assert os.path.exists("/var/data/xx2.txt") assert fs == fake_filesystem def test_pause_resume(fs): fake_temp_file = tempfile.NamedTemporaryFile() assert fs.exists(fake_temp_file.name) assert os.path.exists(fake_temp_file.name) fs.pause() assert fs.exists(fake_temp_file.name) assert not os.path.exists(fake_temp_file.name) real_temp_file = tempfile.NamedTemporaryFile() assert not fs.exists(real_temp_file.name) assert os.path.exists(real_temp_file.name) fs.resume() assert not os.path.exists(real_temp_file.name) assert os.path.exists(fake_temp_file.name) def test_pause_resume_contextmanager(fs): fake_temp_file = tempfile.NamedTemporaryFile() assert fs.exists(fake_temp_file.name) assert os.path.exists(fake_temp_file.name) with Pause(fs): assert fs.exists(fake_temp_file.name) assert not os.path.exists(fake_temp_file.name) real_temp_file = tempfile.NamedTemporaryFile() assert not fs.exists(real_temp_file.name) assert os.path.exists(real_temp_file.name) assert not os.path.exists(real_temp_file.name) assert os.path.exists(fake_temp_file.name) def test_use_own_io_module(fs): filepath = "foo.txt" with open(filepath, "w") as f: f.write("bar") stream = pyfakefs.pytest_tests.io.InputStream(filepath) assert stream.read() == "bar" def test_switch_to_windows(fs): fs.os = OSType.WINDOWS assert os.path.exists(tempfile.gettempdir()) def test_switch_to_linux(fs): fs.os = OSType.LINUX assert os.path.exists(tempfile.gettempdir()) def test_switch_to_macos(fs): fs.os = OSType.MACOS assert os.path.exists(tempfile.gettempdir()) def test_updatecache_problem(fs): # regression test for #1096 filename = r"C:\source_file" fs.create_file(filename) with open(filename): assert True	2.5 KB	2026-01-20 12:58
📄 pytest_reload_pandas_test.py """Regression test for #947. Ensures that reloading the `pandas.core.arrays.arrow.extension_types` module succeeds. """ import sys from pathlib import Path import pytest try: import pandas as pd import parquet except ImportError: pd = None parquet = None @pytest.mark.skipif(pd is None, reason="pandas or parquet not installed") @pytest.mark.skipif(sys.version_info >= (3, 14), reason="parquet not available yet") def test_1(fs): dir_ = Path(__file__).parent / "data" fs.add_real_directory(dir_) pd.read_parquet(dir_ / "test.parquet") @pytest.mark.skipif(pd is None, reason="pandas or parquet not installed") @pytest.mark.skipif(sys.version_info >= (3, 14), reason="parquet not available yet") def test_2(): dir_ = Path(__file__).parent / "data" pd.read_parquet(dir_ / "test.parquet")	828 B	2026-01-20 12:58
📄 test_fs_with_monkeypatch.py from pyfakefs.fake_filesystem import FakeFileOpen def test_monkeypatch_with_fs(fs, monkeypatch): """Regression test for issue 1200""" fake_open = FakeFileOpen(fs) monkeypatch.setattr("builtins.open", fake_open, raising=False) def test_open(): """Tests if open is poisoned by the above test""" assert "built-in" in str(open)	348 B	2026-01-20 12:58
📄 test_patch_on_setup.py from pathlib import Path import pytest from pyfakefs.fake_filesystem import FakeFilesystem def pytest_generate_tests(metafunc): handlers = [a, b, c] if "handler_class" in metafunc.fixturenames: metafunc.parametrize("handler_class", handlers) def a(): pass def b(): pass def c(): pass @pytest.fixture def class_a(): pass @pytest.fixture def class_b(): pass @pytest.fixture def class_c(): pass @pytest.fixture def make_handler(request): def _make_handler(cls): return request.getfixturevalue(f"class_{cls.__name__}") yield _make_handler @pytest.fixture def handler_and_check(handler_class, make_handler): assert Path("/foo/bar").exists() yield def test_handler_and_check_in_fixture(handler_and_check): assert Path("/foo/bar").exists() @pytest.fixture(scope="module", autouse=True) def config(fs_module: FakeFilesystem): fs_module.create_file("/foo/bar")	949 B	2026-01-20 12:58
📄 test_reload_local_import.py import pytest from pyfakefs.fake_filesystem_unittest import Patcher from pyfakefs.fake_pathlib import FakePathlibModule from pyfakefs.helpers import reload_cleanup_handler from pyfakefs.pytest_tests import local_import @pytest.fixture def test_fs(): with Patcher() as patcher: patcher.cleanup_handlers["pyfakefs.pytest_tests.lib_using_pathlib"] = ( reload_cleanup_handler ) yield patcher.fs class TestReloadCleanupHandler: def test1(self, test_fs): path = local_import.load("some_path") assert isinstance(path, FakePathlibModule.Path) def test2(self): path = local_import.load("some_path") # will fail without reload handler assert not isinstance(path, FakePathlibModule.Path)	771 B	2026-01-20 12:58
📄 unhashable.py import sys import types class Unhashable(types.ModuleType): """ Unhashable module, used for regression test for #923. """ @property def Unhashable(self): return self def __eq__(self, other): raise NotImplementedError("Cannot compare unhashable") if sys.modules[__name__] is not Unhashable: sys.modules[__name__] = Unhashable("unhashable")	390 B	2026-01-20 12:58

Edit File:

Terminal