7253604930

Committed 18 Dec 2023 08:44PM UTC coverage: 96.016%. Remained the same

Build # 7253604930

Build Type

Pull #74

github

Committed by

web-flow

Commit Message

Bump actions/upload-artifact from 3 to 4

Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 3 to 4.
- [Release notes](https://github.com/actions/upload-artifact/releases)
- [Commits](https://github.com/actions/upload-artifact/compare/v3...v4)

---
updated-dependencies:
- dependency-name: actions/upload-artifact
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #74: Bump actions/upload-artifact from 3 to 4

Run Details

241 of 251 relevant lines covered (96.02%)

4.78 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.18

/randomfiletree/test/test_core.py

#!/usr/bin/env python3

# std
import unittest
import tempfile
import pathlib
import random
import os
from typing import Generator, List, Tuple

# ours
from randomfiletree.core import (
    iterative_gaussian_tree,
    random_string,
    sample_random_elements,
    choose_random_elements,
)

random.seed(0)


class TestHelperFunctions(unittest.TestCase):
    def setUp(self) -> None:
        self.itries = 10

    def test_get_random_string(self) -> None:
        for i in range(self.itries):
            mi = random.randint(0, 10)
            ma = mi + random.randint(0, 10)
            ras = random_string(mi, ma)
            self.assertGreaterEqual(len(ras), mi)
            self.assertLessEqual(len(ras), ma)


class TestTreeCreation(unittest.TestCase):
    def setUp(self) -> None:
        self.basedir = tempfile.TemporaryDirectory()

    def tearDown(self) -> None:
        self.basedir.cleanup()

    def get_content(self) -> Tuple[List[str], List[str]]:
        alldirs = []
        allfiles = []
        for root, dirs, files in os.walk(self.basedir.name):
            for d in dirs:
                alldirs.append(os.path.join(root, d))
            for file in files:
                allfiles.append(os.path.join(root, file))
        return alldirs, allfiles

    def test_create_random_tree_empty(self) -> None:
        iterative_gaussian_tree(self.basedir.name, -10, -10, 3, None)
        dirs, files = self.get_content()
        self.assertEqual(len(dirs) + len(files), 0)

    def test_create_random_files(self) -> None:
        iterative_gaussian_tree(self.basedir.name, 5, -10, 3, None)
        dirs, files = self.get_content()
        self.assertEqual(len(dirs), 0)
        self.assertGreater(len(files), 1)

    def test_create_random_dirs(self) -> None:
        iterative_gaussian_tree(self.basedir.name, -10, 2, 3, None)
        dirs, files = self.get_content()
        self.assertEqual(len(files), 0)
        self.assertGreater(len(dirs), 1)

    def test_create_both(self) -> None:
        iterative_gaussian_tree(self.basedir.name, 3, 3, 3, None)
        dirs, files = self.get_content()
        self.assertGreater(len(files), 1)
        self.assertGreater(len(dirs), 1)

    def test_limit_depth(self) -> None:
        iterative_gaussian_tree(self.basedir.name, 3, 2, 5, maxdepth=3)
        dirs, files = self.get_content()
        max_depth = max(
            map(lambda x: x.count(os.sep), dirs)
        ) - self.basedir.name.count(os.sep)
        self.assertLessEqual(max_depth, 4)

    def test_fname(self) -> None:
        suffix = ".jpg"
        iterative_gaussian_tree(
            self.basedir.name,
            3,
            2,
            5,
            maxdepth=3,
            filename=lambda: random_string() + suffix,
        )
        _, files = self.get_content()
        for file in files:
            self.assertEqual(pathlib.Path(file).suffix, suffix)

    def test_payload(self) -> None:
        content = "testtest"
        suffix = ".txt"

        def callback(
            target_dir: pathlib.Path,
        ) -> Generator[pathlib.Path, None, None]:
            while True:
                path = target_dir / (random_string() + suffix)
                with path.open("w") as f:
                    f.write(content)
                yield path

        iterative_gaussian_tree(
            self.basedir.name, 3, 2, 5, maxdepth=3, payload=callback
        )
        _, files = self.get_content()
        for file in files:
            self.assertEqual(pathlib.Path(file).suffix, suffix)
            with open(file, "r") as f:
                self.assertEqual(f.read(), content)


class TestChooseSample(unittest.TestCase):
    def setUp(self) -> None:
        self.basedir = tempfile.TemporaryDirectory()

    def reset(self) -> None:
        self.basedir.cleanup()
        self.basedir = tempfile.TemporaryDirectory()

    def tearDown(self) -> None:
        self.basedir.cleanup()

    def test_sample(self) -> None:
        self.reset()
        iterative_gaussian_tree(self.basedir.name, 5, 5, 4)
        dirs, files = sample_random_elements(self.basedir.name, 2, 2)
        self.assertEqual(len(set(dirs)), 2)
        self.assertEqual(len(set(files)), 2)

    def test_sample_raises(self) -> None:
        self.reset()
        with self.assertRaises(ValueError):
            sample_random_elements(self.basedir.name, 2, 2)

    def test_sample_ignore(self) -> None:
        self.reset()
        dirs, files = sample_random_elements(self.basedir.name, 2, 2, "ignore")
        self.assertEqual(len(set(dirs)), 0)
        self.assertEqual(len(set(files)), 0)
        self.reset()
        os.mkdir(os.path.join(self.basedir.name, "test"))
        dirs, files = sample_random_elements(self.basedir.name, 2, 2, "ignore")
        self.assertEqual(len(set(dirs)), 1)
        self.assertEqual(len(set(files)), 0)

    def test_choose(self) -> None:
        self.reset()
        iterative_gaussian_tree(self.basedir.name, 5, 5, 3)
        dirs, files = choose_random_elements(self.basedir.name, 5, 3)
        self.assertEqual(len(dirs), 5)
        self.assertEqual(len(files), 3)

    def test_choose_raise(self) -> None:
        self.reset()
        with self.assertRaises(ValueError):
            # noinspection PyUnusedLocal
            dirs, files = choose_random_elements(self.basedir.name, 5, 3)

    def test_choose_ignore(self) -> None:
        self.reset()
        dirs, files = choose_random_elements(self.basedir.name, 2, 2, "ignore")
        self.assertEqual(len(dirs), 0)
        self.assertEqual(len(files), 0)


if __name__ == "__main__":
    unittest.main()

1	#!/usr/bin/env python3
2
3	# std
4	import unittest	5✔
5	import tempfile	5✔
6	import pathlib	5✔
7	import random	5✔
8	import os	5✔
9	from typing import Generator, List, Tuple	5✔
10
11	# ours
12	from randomfiletree.core import (	5✔
13	iterative_gaussian_tree,
14	random_string,
15	sample_random_elements,
16	choose_random_elements,
17	)
18
19	random.seed(0)	5✔
20
21
22	class TestHelperFunctions(unittest.TestCase):	5✔
23	def setUp(self) -> None:	5✔
24	self.itries = 10	5✔
25
26	def test_get_random_string(self) -> None:	5✔
27	for i in range(self.itries):	5✔
28	mi = random.randint(0, 10)	5✔
29	ma = mi + random.randint(0, 10)	5✔
30	ras = random_string(mi, ma)	5✔
31	self.assertGreaterEqual(len(ras), mi)	5✔
32	self.assertLessEqual(len(ras), ma)	5✔
33
34
35	class TestTreeCreation(unittest.TestCase):	5✔
36	def setUp(self) -> None:	5✔
37	self.basedir = tempfile.TemporaryDirectory()	5✔
38
39	def tearDown(self) -> None:	5✔
40	self.basedir.cleanup()	5✔
41
42	def get_content(self) -> Tuple[List[str], List[str]]:	5✔
43	alldirs = []	5✔
44	allfiles = []	5✔
45	for root, dirs, files in os.walk(self.basedir.name):	5✔
46	for d in dirs:	5✔
47	alldirs.append(os.path.join(root, d))	5✔
48	for file in files:	5✔
49	allfiles.append(os.path.join(root, file))	5✔
50	return alldirs, allfiles	5✔
51
52	def test_create_random_tree_empty(self) -> None:	5✔
53	iterative_gaussian_tree(self.basedir.name, -10, -10, 3, None)	5✔
54	dirs, files = self.get_content()	5✔
55	self.assertEqual(len(dirs) + len(files), 0)	5✔
56
57	def test_create_random_files(self) -> None:	5✔
58	iterative_gaussian_tree(self.basedir.name, 5, -10, 3, None)	5✔
59	dirs, files = self.get_content()	5✔
60	self.assertEqual(len(dirs), 0)	5✔
61	self.assertGreater(len(files), 1)	5✔
62
63	def test_create_random_dirs(self) -> None:	5✔
64	iterative_gaussian_tree(self.basedir.name, -10, 2, 3, None)	5✔
65	dirs, files = self.get_content()	5✔
66	self.assertEqual(len(files), 0)	5✔
67	self.assertGreater(len(dirs), 1)	5✔
68
69	def test_create_both(self) -> None:	5✔
70	iterative_gaussian_tree(self.basedir.name, 3, 3, 3, None)	5✔
71	dirs, files = self.get_content()	5✔
72	self.assertGreater(len(files), 1)	5✔
73	self.assertGreater(len(dirs), 1)	5✔
74
75	def test_limit_depth(self) -> None:	5✔
76	iterative_gaussian_tree(self.basedir.name, 3, 2, 5, maxdepth=3)	5✔
77	dirs, files = self.get_content()	5✔
78	max_depth = max(	5✔
79	map(lambda x: x.count(os.sep), dirs)
80	) - self.basedir.name.count(os.sep)
81	self.assertLessEqual(max_depth, 4)	5✔
82
83	def test_fname(self) -> None:	5✔
84	suffix = ".jpg"	5✔
85	iterative_gaussian_tree(	5✔
86	self.basedir.name,
87	3,
88	2,
89	5,
90	maxdepth=3,
91	filename=lambda: random_string() + suffix,
92	)
93	_, files = self.get_content()	5✔
94	for file in files:	5✔
95	self.assertEqual(pathlib.Path(file).suffix, suffix)	5✔
96
97	def test_payload(self) -> None:	5✔
98	content = "testtest"	5✔
99	suffix = ".txt"	5✔
100
101	def callback(	5✔
102	target_dir: pathlib.Path,
103	) -> Generator[pathlib.Path, None, None]:
104	while True:	3✔
105	path = target_dir / (random_string() + suffix)	5✔
106	with path.open("w") as f:	5✔
107	f.write(content)	5✔
108	yield path	5✔
109
110	iterative_gaussian_tree(	5✔
111	self.basedir.name, 3, 2, 5, maxdepth=3, payload=callback
112	)
113	_, files = self.get_content()	5✔
114	for file in files:	5✔
115	self.assertEqual(pathlib.Path(file).suffix, suffix)	5✔
116	with open(file, "r") as f:	5✔
117	self.assertEqual(f.read(), content)	5✔
118
119
120	class TestChooseSample(unittest.TestCase):	5✔
121	def setUp(self) -> None:	5✔
122	self.basedir = tempfile.TemporaryDirectory()	5✔
123
124	def reset(self) -> None:	5✔
125	self.basedir.cleanup()	5✔
126	self.basedir = tempfile.TemporaryDirectory()	5✔
127
128	def tearDown(self) -> None:	5✔
129	self.basedir.cleanup()	5✔
130
131	def test_sample(self) -> None:	5✔
132	self.reset()	5✔
133	iterative_gaussian_tree(self.basedir.name, 5, 5, 4)	5✔
134	dirs, files = sample_random_elements(self.basedir.name, 2, 2)	5✔
135	self.assertEqual(len(set(dirs)), 2)	5✔
136	self.assertEqual(len(set(files)), 2)	5✔
137
138	def test_sample_raises(self) -> None:	5✔
139	self.reset()	5✔
140	with self.assertRaises(ValueError):	5✔
141	sample_random_elements(self.basedir.name, 2, 2)	5✔
142
143	def test_sample_ignore(self) -> None:	5✔
144	self.reset()	5✔
145	dirs, files = sample_random_elements(self.basedir.name, 2, 2, "ignore")	5✔
146	self.assertEqual(len(set(dirs)), 0)	5✔
147	self.assertEqual(len(set(files)), 0)	5✔
148	self.reset()	5✔
149	os.mkdir(os.path.join(self.basedir.name, "test"))	5✔
150	dirs, files = sample_random_elements(self.basedir.name, 2, 2, "ignore")	5✔
151	self.assertEqual(len(set(dirs)), 1)	5✔
152	self.assertEqual(len(set(files)), 0)	5✔
153
154	def test_choose(self) -> None:	5✔
155	self.reset()	5✔
156	iterative_gaussian_tree(self.basedir.name, 5, 5, 3)	5✔
157	dirs, files = choose_random_elements(self.basedir.name, 5, 3)	5✔
158	self.assertEqual(len(dirs), 5)	5✔
159	self.assertEqual(len(files), 3)	5✔
160
161	def test_choose_raise(self) -> None:	5✔
162	self.reset()	5✔
163	with self.assertRaises(ValueError):	5✔
164	# noinspection PyUnusedLocal
165	dirs, files = choose_random_elements(self.basedir.name, 5, 3)	5✔
166
167	def test_choose_ignore(self) -> None:	5✔
168	self.reset()	5✔
169	dirs, files = choose_random_elements(self.basedir.name, 2, 2, "ignore")	5✔
170	self.assertEqual(len(dirs), 0)	5✔
171	self.assertEqual(len(files), 0)	5✔
172
173
174	if __name__ == "__main__":	5✔
175	unittest.main()	×

klieret / RandomFileTree / 7253604930

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous