1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
# Copyright 2014 Altera Corporation. All Rights Reserved.
# 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.example` module to demonstrate the usage of the
:py:class`pyfakefs.fake_filesystem_unittest.TestCase` base class.
Fake filesystem functions like `create_file()`, `create_dir()` or
`create_symlink()` are often used to set up file structures at the beginning
of a test.
While you could also use the familiar `open()`, `os.mkdirs()` and similar
functions, these functions can make the test code shorter and more readable.
`create_file()` is particularly convenient because it creates all parent
directories and allows you to specify the contents or the size of the file.
"""
import io
import os
import sys
import unittest
from pyfakefs import fake_filesystem_unittest
from pyfakefs.extra_packages import use_scandir_package
from pyfakefs.tests import example # The module under test
def load_tests(loader, tests, ignore):
"""Load the pyfakefs/example.py doctest tests into unittest."""
return fake_filesystem_unittest.load_doctests(loader, tests, ignore, example)
class TestExample(fake_filesystem_unittest.TestCase): # pylint: disable=R0904
"""Test the example module.
The os and shutil modules have been replaced with the fake modules,
so that all of the calls to os and shutil in the tested example code
occur in the fake filesystem.
"""
def setUp(self):
"""Invoke the :py:class:`pyfakefs.fake_filesystem_unittest.TestCase`
`self.setUp()` method. This defines:
* Attribute `self.fs`, an instance of
:py:class:`pyfakefs.fake_filesystem.FakeFilesystem`. This is useful
for creating test files.
* Attribute `self.stubs`, an instance of
:py:class:`pyfakefs.mox3_stubout.StubOutForTesting`. Use this if
you need to define additional stubs.
"""
# This is before setUpPyfakefs(), so still using the real file system
self.filepath = os.path.realpath(__file__)
with io.open(self.filepath, "rb") as f:
self.real_contents = f.read()
self.setUpPyfakefs()
def tearDown(self):
# No longer need self.tearDownPyfakefs()
pass
def test_create_file(self):
"""Test example.create_file() which uses `open()`
and `file.write()`.
"""
self.assertFalse(os.path.isdir("/test"))
os.mkdir("/test")
self.assertTrue(os.path.isdir("/test"))
self.assertFalse(os.path.exists("/test/file.txt"))
example.create_file("/test/file.txt")
self.assertTrue(os.path.exists("/test/file.txt"))
def test_delete_file(self):
"""Test example.delete_file() which uses `os.remove()`."""
self.fs.create_file("/test/full.txt", contents="First line\n" "Second Line\n")
self.assertTrue(os.path.exists("/test/full.txt"))
example.delete_file("/test/full.txt")
self.assertFalse(os.path.exists("/test/full.txt"))
def test_file_exists(self):
"""Test example.path_exists() which uses `os.path.exists()`."""
self.assertFalse(example.path_exists("/test/empty.txt"))
self.fs.create_file("/test/empty.txt")
self.assertTrue(example.path_exists("/test/empty.txt"))
def test_get_globs(self):
"""Test example.get_glob()."""
self.assertFalse(os.path.isdir("/test"))
self.fs.create_dir("/test/dir1/dir2a")
self.assertTrue(os.path.isdir("/test/dir1/dir2a"))
# os.mkdirs() works, too.
os.makedirs("/test/dir1/dir2b")
self.assertTrue(os.path.isdir("/test/dir1/dir2b"))
self.assertEqual(example.get_glob("/test/dir1/nonexistent*"), [])
is_windows = sys.platform.startswith("win")
matching_paths = sorted(example.get_glob("/test/dir1/dir*"))
if is_windows:
self.assertEqual(matching_paths, [r"/test/dir1\dir2a", r"/test/dir1\dir2b"])
else:
self.assertEqual(matching_paths, ["/test/dir1/dir2a", "/test/dir1/dir2b"])
def test_rm_tree(self):
"""Test example.rm_tree() using `shutil.rmtree()`."""
self.fs.create_dir("/test/dir1/dir2a")
# os.mkdirs() works, too.
os.makedirs("/test/dir1/dir2b")
self.assertTrue(os.path.isdir("/test/dir1/dir2b"))
self.assertTrue(os.path.isdir("/test/dir1/dir2a"))
example.rm_tree("/test/dir1")
self.assertFalse(os.path.exists("/test/dir1"))
def test_os_scandir(self):
"""Test example.scandir() which uses `os.scandir()`.
The os module has been replaced with the fake os module so the
fake filesystem path entries are returned instead of `os.DirEntry`
objects.
"""
self.fs.create_file("/test/text.txt")
self.fs.create_dir("/test/dir")
self.fs.create_file("/linktest/linked")
self.fs.create_symlink("/test/linked_file", "/linktest/linked")
entries = sorted(example.scan_dir("/test"), key=lambda e: e.name)
self.assertEqual(3, len(entries))
self.assertEqual("linked_file", entries[1].name)
self.assertTrue(entries[0].is_dir())
self.assertTrue(entries[1].is_symlink())
self.assertTrue(entries[2].is_file())
@unittest.skipIf(
not use_scandir_package, "Testing only if scandir module is installed"
)
def test_scandir_scandir(self):
"""Test example.scandir() which uses `scandir.scandir()`.
The scandir module has been replaced with the fake_scandir module so
the fake filesystem path entries are returned instead of
`scandir.DirEntry` objects.
"""
self.fs.create_file("/test/text.txt")
self.fs.create_dir("/test/dir")
entries = sorted(example.scan_dir("/test"), key=lambda e: e.name)
self.assertEqual(2, len(entries))
self.assertEqual("text.txt", entries[1].name)
self.assertTrue(entries[0].is_dir())
self.assertTrue(entries[1].is_file())
def test_real_file_access(self):
"""Test `example.file_contents()` for a real file after adding it using
`add_real_file()`."""
with self.assertRaises(OSError):
example.file_contents(self.filepath)
self.fs.add_real_file(self.filepath)
self.assertEqual(example.file_contents(self.filepath), self.real_contents)
if __name__ == "__main__":
unittest.main()
|
