FM / tests

/opt/cloudlinux/venv/lib/python3.11/site-packages/pyfakefs/tests/

/opt/cloudlinux/venv/lib/python3.11/site-packages/pyfakefs/tests

Name	Size	Mode	Actions
fixtures/	-	0755	rm
__pycache__/	-	0755	rm
all_tests.py	2602	0644	edit dl rm
all_tests_without_extra_packages.py	993	0644	edit dl rm
dynamic_patch_test.py	2083	0644	edit dl rm
example.py	4003	0644	edit dl rm
example_test.py	7002	0644	edit dl rm
fake_filesystem_glob_test.py	2821	0644	edit dl rm
fake_filesystem_shutil_test.py	23897	0644	edit dl rm
fake_filesystem_test.py	113311	0644	edit dl rm
fake_filesystem_unittest_test.py	39720	0644	edit dl rm
fake_filesystem_vs_real_test.py	30696	0644	edit dl rm
fake_legacy_modules_test.py	3744	0644	edit dl rm
fake_open_test.py	91200	0644	edit dl rm
fake_os_test.py	244792	0644	edit dl rm
fake_pathlib_test.py	71892	0644	edit dl rm
fake_stat_time_test.py	22353	0644	edit dl rm
fake_tempfile_test.py	4199	0644	edit dl rm
import_as_example.py	3235	0644	edit dl rm
logsio.py	832	0644	edit dl rm
mox3_stubout_example.py	893	0644	edit dl rm
mox3_stubout_test.py	5336	0644	edit dl rm
patched_packages_test.py	2570	0644	edit dl rm
performance_test.py	2622	0644	edit dl rm
skipped_pathlib.py	1211	0644	edit dl rm
test_utils.py	16442	0644	edit dl rm
__init__.py	0	0644	edit dl rm

Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/pyfakefs/tests/fake_filesystem_unittest_test.py (39720B)

# Copyright 2014 Altera Corporation. All Rights Reserved.
# Copyright 2015-2017 John McGehee
# Author: John McGehee
#
# 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.

"""
Test the :py:class`pyfakefs.fake_filesystem_unittest.TestCase` base class.
"""

import glob
import importlib.util
import io
import multiprocessing
import os
import pathlib
import runpy
import shutil
import sys
import tempfile
import unittest
import warnings
from contextlib import redirect_stdout
from io import StringIO
from pathlib import Path
from unittest import TestCase, mock

import pyfakefs.tests.import_as_example
import pyfakefs.tests.logsio
from pyfakefs import fake_filesystem_unittest, fake_filesystem
from pyfakefs.fake_filesystem import OSType
from pyfakefs.fake_filesystem_unittest import (
    Patcher,
    Pause,
    patchfs,
    PatchMode,
)
from pyfakefs.tests.fixtures import module_with_attributes

if sys.version_info < (3, 12):
    # distutils removed in Python 3.12
    from distutils.dir_util import copy_tree, remove_tree

# Work around pyupgrade auto-rewriting `io.open()` to `open()`.
io_open = io.open

class TestPatcher(TestCase):
    def test_context_manager(self):
        with Patcher() as patcher:
            patcher.fs.create_file("/foo/bar", contents="test")
            with open("/foo/bar", encoding="utf8") as f:
                contents = f.read()
            self.assertEqual("test", contents)

@patchfs
    def test_context_decorator(self, fake_fs):
        fake_fs.create_file("/foo/bar", contents="test")
        with open("/foo/bar", encoding="utf8") as f:
            contents = f.read()
        self.assertEqual("test", contents)

def test_nested_invocation(self):
        with Patcher() as patcher:
            patcher.fs.create_file("/foo/bar", contents="test")
            self.assertTrue(patcher.fs.exists("/foo/bar"))
            with Patcher() as patcher1:
                self.assertTrue(patcher1.fs.exists("/foo/bar"))
                patcher1.fs.create_file("/foo/baz", contents="test")
                self.assertTrue(patcher1.fs.exists("/foo/baz"))
            self.assertTrue(patcher.fs.exists("/foo/baz"))

def test_nested_invocation_with_args(self):
        with Patcher() as patcher:
            patcher.fs.create_file("/foo/bar", contents="test")
            with self.assertWarnsRegex(
                UserWarning, "Nested fake filesystem invocation using custom arguments"
            ):
                with Patcher(allow_root_user=False):
                    pass

class TestPatchfsArgumentOrder(TestCase):
    @patchfs
    @mock.patch("os.system")
    def test_argument_order1(self, fake_fs, patched_system):
        fake_fs.create_file("/foo/bar", contents="test")
        with open("/foo/bar", encoding="utf8") as f:
            contents = f.read()
        self.assertEqual("test", contents)
        os.system("foo")
        patched_system.assert_called_with("foo")

@mock.patch("os.system")
    @patchfs
    def test_argument_order2(self, patched_system, fake_fs):
        fake_fs.create_file("/foo/bar", contents="test")
        with open("/foo/bar", encoding="utf8") as f:
            contents = f.read()
        self.assertEqual("test", contents)
        os.system("foo")
        patched_system.assert_called_with("foo")

class TestPyfakefsUnittestBase(fake_filesystem_unittest.TestCase):
    def setUp(self):
        """Set up the fake file system"""
        self.setUpPyfakefs()

class TestPyfakefsUnittest(TestPyfakefsUnittestBase):  # pylint: disable=R0904
    """Test the `pyfakefs.fake_filesystem_unittest.TestCase` base class."""

def test_open(self):
        """Fake `open()` function is bound"""
        self.assertFalse(os.path.exists("/fake_file.txt"))
        with open("/fake_file.txt", "w", encoding="utf8") as f:
            f.write("This test file was created using the open() function.\n")
        self.assertTrue(self.fs.exists("/fake_file.txt"))
        with open("/fake_file.txt", encoding="utf8") as f:
            content = f.read()
        self.assertEqual(
            "This test file was created using the open() function.\n",
            content,
        )

def test_io_open(self):
        """Fake io module is bound"""
        self.assertFalse(os.path.exists("/fake_file.txt"))
        with io_open("/fake_file.txt", "w", encoding="utf8") as f:
            f.write("This test file was created using the io.open() function.\n")
        self.assertTrue(self.fs.exists("/fake_file.txt"))
        with open("/fake_file.txt", encoding="utf8") as f:
            content = f.read()
        self.assertEqual(
            "This test file was created using the io.open() function.\n",
            content,
        )

def test_os(self):
        """Fake os module is bound"""
        self.assertFalse(self.fs.exists("/test/dir1/dir2"))
        os.makedirs("/test/dir1/dir2")
        self.assertTrue(self.fs.exists("/test/dir1/dir2"))

def test_glob(self):
        """Fake glob module is bound"""
        is_windows = sys.platform.startswith("win")
        self.assertEqual([], glob.glob("/test/dir1/dir*"))
        self.fs.create_dir("/test/dir1/dir2a")
        matching_paths = glob.glob("/test/dir1/dir*")
        if is_windows:
            self.assertEqual([r"/test/dir1\dir2a"], matching_paths)
        else:
            self.assertEqual(["/test/dir1/dir2a"], matching_paths)
        self.fs.create_dir("/test/dir1/dir2b")
        matching_paths = sorted(glob.glob("/test/dir1/dir*"))
        if is_windows:
            self.assertEqual([r"/test/dir1\dir2a", r"/test/dir1\dir2b"], matching_paths)
        else:
            self.assertEqual(["/test/dir1/dir2a", "/test/dir1/dir2b"], matching_paths)

def test_shutil(self):
        """Fake shutil module is bound"""
        self.fs.create_dir("/test/dir1/dir2a")
        self.fs.create_dir("/test/dir1/dir2b")
        self.assertTrue(self.fs.exists("/test/dir1/dir2b"))
        self.assertTrue(self.fs.exists("/test/dir1/dir2a"))

shutil.rmtree("/test/dir1")
        self.assertFalse(self.fs.exists("/test/dir1"))

def test_fakepathlib(self):
        p = pathlib.Path("/fake_file.txt")
        with p.open("w", encoding="utf8") as f:
            f.write("text")
        is_windows = sys.platform.startswith("win")
        if is_windows:
            self.assertTrue(self.fs.exists(r"\fake_file.txt"))
        else:
            self.assertTrue(self.fs.exists("/fake_file.txt"))

class TestPatchingImports(TestPyfakefsUnittestBase):
    def test_import_as_other_name(self):
        file_path = "/foo/bar/baz"
        self.fs.create_file(file_path)
        self.assertTrue(self.fs.exists(file_path))
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists1(file_path))

def test_import_path_from_os(self):
        """Make sure `from os import path` patches `path`."""
        file_path = "/foo/bar/baz"
        self.fs.create_file(file_path)
        self.assertTrue(self.fs.exists(file_path))
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists2(file_path))

def test_import_path_from_pathlib(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists3(file_path))

def test_import_exists_from_os_path(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists5(file_path))

def test_import_isfile_from_os_path(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_isfile(file_path))

def test_import_isdir_from_os_path(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_isdir(file_path))

def test_import_islink_from_os_path(self):
        file_path = "/foo/bar"
        link_path = "/foo/link"
        self.fs.create_file(file_path)
        self.fs.create_symlink(link_path, file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_islink(link_path))

def test_import_function_from_os_path_as_other_name(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists6(file_path))

def test_import_pathlib_path(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists7(file_path))

def test_import_function_from_os(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        stat_result = pyfakefs.tests.import_as_example.file_stat1(file_path)
        self.assertEqual(3, stat_result.st_size)

def test_import_function_from_os_as_other_name(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        stat_result = pyfakefs.tests.import_as_example.file_stat2(file_path)
        self.assertEqual(3, stat_result.st_size)

def test_import_open_as_other_name(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        contents = pyfakefs.tests.import_as_example.file_contents1(file_path)
        self.assertEqual("abc", contents)

def test_import_io_open_as_other_name(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        contents = pyfakefs.tests.import_as_example.file_contents2(file_path)
        self.assertEqual("abc", contents)

class TestPatchingDefaultArgs(fake_filesystem_unittest.TestCase):
    def setUp(self):
        self.setUpPyfakefs(patch_default_args=True)

def test_path_exists_as_default_arg_in_function(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists4(file_path))

def test_path_exists_as_default_arg_in_method(self):
        file_path = "/foo/bar"
        self.fs.create_dir(file_path)
        sut = pyfakefs.tests.import_as_example.TestDefaultArg()
        self.assertTrue(sut.check_if_exists(file_path))

def test_fake_path_exists4(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists4("foo"))

class TestAttributesWithFakeModuleNames(TestPyfakefsUnittestBase):
    """Test that module attributes with names like `path` or `io` are not
    stubbed out.
    """

def test_attributes(self):
        """Attributes of module under test are not patched"""
        self.assertEqual(module_with_attributes.os, "os attribute value")
        self.assertEqual(module_with_attributes.path, "path attribute value")
        self.assertEqual(module_with_attributes.pathlib, "pathlib attribute value")
        self.assertEqual(module_with_attributes.shutil, "shutil attribute value")
        self.assertEqual(module_with_attributes.io, "io attribute value")

import math as path  # noqa: E402 wanted import not at top

class TestPathNotPatchedIfNotOsPath(TestPyfakefsUnittestBase):
    """Tests that `path` is not patched if it is not `os.path`.
    An own path module (in this case an alias to math) can be imported
    and used.
    """

def test_own_path_module(self):
        self.assertEqual(2, path.floor(2.5))

class FailedPatchingTest(TestPyfakefsUnittestBase):
    """Negative tests: make sure the tests for `modules_to_reload` and
    `modules_to_patch` fail if not providing the arguments.
    """

@unittest.expectedFailure
    def test_system_stat(self):
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"test")
        self.assertEqual(
            4, pyfakefs.tests.import_as_example.system_stat(file_path).st_size
        )

class ReloadModuleTest(fake_filesystem_unittest.TestCase):
    """Make sure that reloading a module allows patching of classes not
    patched automatically.
    """

def setUp(self):
        """Set up the fake file system"""
        self.setUpPyfakefs(modules_to_reload=[pyfakefs.tests.import_as_example])

class NoSkipNamesTest(fake_filesystem_unittest.TestCase):
    """Reference test for additional_skip_names tests:
    make sure that the module is patched by default."""

def setUp(self):
        self.setUpPyfakefs()

def test_path_exists(self):
        self.assertFalse(pyfakefs.tests.import_as_example.exists_this_file())

def test_fake_path_exists1(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists1("foo"))

def test_fake_path_exists2(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists2("foo"))

def test_fake_path_exists3(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists3("foo"))

def test_fake_path_exists5(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists5("foo"))

def test_fake_path_exists6(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists6("foo"))

def test_fake_path_exists7(self):
        self.fs.create_file("foo")
        self.assertTrue(pyfakefs.tests.import_as_example.check_if_exists7("foo"))

def test_open_fails(self):
        with self.assertRaises(OSError):
            pyfakefs.tests.import_as_example.open_this_file()

def test_open_patched_in_module_ending_with_io(self):
        # regression test for #569
        file_path = "/foo/bar"
        self.fs.create_file(file_path, contents=b"abc")
        contents = pyfakefs.tests.logsio.file_contents(file_path)
        self.assertEqual(b"abc", contents)

class AdditionalSkipNamesTest(fake_filesystem_unittest.TestCase):
    """Make sure that modules in additional_skip_names are not patched.
    Passes module name to `additional_skip_names`."""

def setUp(self):
        self.setUpPyfakefs(additional_skip_names=["pyfakefs.tests.import_as_example"])

def test_path_exists(self):
        self.assertTrue(pyfakefs.tests.import_as_example.exists_this_file())

def test_fake_path_does_not_exist1(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists1("foo"))

def test_fake_path_does_not_exist2(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists2("foo"))

def test_fake_path_does_not_exist3(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists3("foo"))

def test_fake_path_does_not_exist4(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists4("foo"))

def test_fake_path_does_not_exist5(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists5("foo"))

def test_fake_path_does_not_exist6(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists6("foo"))

def test_fake_path_does_not_exist7(self):
        self.fs.create_file("foo")
        self.assertFalse(pyfakefs.tests.import_as_example.check_if_exists7("foo"))

def test_open_succeeds(self):
        pyfakefs.tests.import_as_example.open_this_file()

def test_path_succeeds(self):
        pyfakefs.tests.import_as_example.return_this_file_path()

class AdditionalSkipNamesModuleTest(fake_filesystem_unittest.TestCase):
    """Make sure that modules in additional_skip_names are not patched.
    Passes module to `additional_skip_names`."""

def setUp(self):
        self.setUpPyfakefs(additional_skip_names=[pyfakefs.tests.import_as_example])