Coverage for api/tests/test_cli.py : 0%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1# import os
3import pytest
4from click.testing import CliRunner
6from shopyo.api.cli import cli
7from shopyo.api.constants import SEP_CHAR
8from shopyo.api.constants import SEP_NUM
10pytestmark = pytest.mark.cli_unit
13@pytest.fixture(scope="session")
14def cli_runner():
15 """Fixture that returns a helper function to run the shopyo cli."""
16 runner = CliRunner()
18 def cli_main(*cli_args, **cli_kwargs):
19 """Run shopyo cli main with the given args."""
20 return runner.invoke(cli, cli_args, **cli_kwargs)
22 return cli_main
25@pytest.mark.usefixtures("restore_cwd")
26class TestCliCreateBox:
27 """test the create_box command line api function"""
29 def test_create_existing_box(self, tmpdir, cli_runner):
30 tmpdir.mkdir("modules").mkdir("box__foo")
31 os.chdir(tmpdir)
32 module_path = os.path.join("modules", "box__foo")
33 result = cli_runner("startbox", "box__foo")
34 expected = f"[ ] unable to create. Box {module_path} already exists!"
36 assert result.exit_code != 0
37 assert expected in result.output
39 @pytest.mark.parametrize("opt", ["-v", "--verbose"])
40 def test_create_unique_box(self, tmpdir, cli_runner, opt):
41 tmpdir.mkdir("modules")
42 os.chdir(tmpdir)
43 result = cli_runner("startbox", "box__foo", opt)
44 module_path = os.path.join("modules", "box__foo")
45 expected = f"[x] Successfully created dir {module_path}"
47 assert result.exit_code == 0
48 assert os.path.exists(os.path.join("modules", "box__foo"))
49 assert os.path.exists(os.path.join("modules", "box__foo", "box_info.json"))
50 assert expected in result.output
53@pytest.mark.usefixtures("restore_cwd")
54@pytest.mark.order("last")
55class TestCliClean:
56 """tests the clean command line api function"""
58 def test_clean_pycache_present_only_in_cwd(self, tmpdir, flask_app):
59 """
60 run `shopyo clean2 -v` on the following test directory:
62 <some-unique-tmpdir>/
63 __pycache__/
64 file.pyc
65 """
66 fd = tmpdir.mkdir("__pycache__").join("file.pyc")
67 fd.write("content")
68 os.chdir(tmpdir)
69 runner = flask_app.test_cli_runner(mix_stderr=False)
70 result = runner.invoke(cli, ["clean", "-v"])
71 expected_out = "[x] all tables dropped\n[x] __pycache__ successfully deleted\n"
72 expected_err_shopyo_db = (
73 f"[ ] unable to delete {os.path.join(tmpdir, 'shopyo.db')}"
74 )
75 expected_err_migrations = (
76 f"[ ] unable to delete {os.path.join(tmpdir, 'migrations')}"
77 )
79 assert result.exit_code == 0
80 assert os.path.exists("__pycache__") is False
81 assert expected_out in result.output
82 assert expected_err_shopyo_db in result.stderr
83 assert expected_err_migrations in result.stderr
85 def test_clean_pycache_many_lvls_below_cwd(self, tmpdir, flask_app):
86 """
87 run `shopyo clean2 -v` on the following test directory:
89 <some-unique-tmpdir>/
90 shopyo/
91 shopyo/
92 mod/
93 box/
94 __pycache__/
95 file.pyc
96 """
98 path = tmpdir.mkdir("shopyo").mkdir("shopyo").mkdir("mod").mkdir("box")
99 pycache_path = path.mkdir("__pycache__")
100 pyc = pycache_path.join("file.pyc")
101 pyc.write("content")
102 os.chdir(tmpdir)
103 runner = flask_app.test_cli_runner()
104 result = runner.invoke(cli, ["clean", "-v"])
105 expected_out = "[x] all tables dropped\n[x] __pycache__ successfully deleted\n"
106 expected_err_shopyo_db = (
107 f"[ ] unable to delete {os.path.join(tmpdir, 'shopyo.db')}"
108 )
109 expected_err_migrations = (
110 f"[ ] unable to delete {os.path.join(tmpdir, 'migrations')}"
111 )
113 assert result.exit_code == 0
114 assert os.path.exists(pycache_path) is False
115 assert expected_out in result.output
116 assert expected_err_shopyo_db in result.output
117 assert expected_err_migrations in result.output
119 def test_clean_many_pycache_in_nested_dirs(self, tmpdir, flask_app):
120 """
121 run `shopyo clean2 -v` on the following test directory:
123 <some-unique-tmpdir>/
124 __pycache__/
125 file.pyc
126 shopyo/
127 __pycache__
128 file.pyc
129 module/
130 __pycache__
131 file.pyc
132 """
133 pycache_path1 = tmpdir.mkdir("__pycache__")
134 pyc1 = pycache_path1.join("file.pyc")
135 pyc1.write("content")
136 shopyo_path = tmpdir.mkdir("shopyo")
137 pycache_path2 = shopyo_path.mkdir("__pycache__")
138 pyc2 = pycache_path2.join("file.pyc")
139 pyc2.write("content")
140 pycache_path3 = shopyo_path.mkdir("module").mkdir("__pycache__")
141 pyc3 = pycache_path3.join("file.pyc")
142 pyc3.write("content")
143 os.chdir(tmpdir)
144 runner = flask_app.test_cli_runner()
145 result = runner.invoke(cli, ["clean", "-v"])
146 expected_out = "[x] all tables dropped\n[x] __pycache__ successfully deleted\n"
147 expected_err_shopyo_db = (
148 f"[ ] unable to delete {os.path.join(tmpdir, 'shopyo.db')}"
149 )
150 expected_err_migrations = (
151 f"[ ] unable to delete {os.path.join(tmpdir, 'migrations')}"
152 )
154 assert result.exit_code == 0
155 assert os.path.exists(pycache_path1) is False
156 assert os.path.exists(pycache_path2) is False
157 assert os.path.exists(pycache_path3) is False
158 assert expected_out in result.output
159 assert expected_err_shopyo_db in result.output
160 assert expected_err_migrations in result.output
162 def test_no_clean_applied_on_multiple_pycache(self, tmpdir):
163 """
164 run no clean command on the following test directory:
166 <some-unique-tmpdir>/
167 __pycache__/
168 shopyo/
169 __pycache__/
171 """
172 path1 = tmpdir.mkdir("__pycache__")
173 path2 = tmpdir.mkdir("shopyo").mkdir("__pycache__")
175 assert os.path.exists(path1)
176 assert os.path.exists(path2)
178 def test_clean_on_skip_shopyo_db_file(self, tmpdir, flask_app):
179 """
180 run `shopyo clean2 -v` on the following test directory:
182 <some-unique-tmpdir>/
183 shopyo.db
184 """
185 shopyo_db = tmpdir.join("shopyo.db")
186 shopyo_db.write("content")
187 os.chdir(tmpdir)
188 runner = flask_app.test_cli_runner()
189 result = runner.invoke(cli, ["clean", "--no-clear-db", "-v"])
190 part_expected_out = "[ ] db clearing skipped"
192 assert result.exit_code == 0
193 assert os.path.exists(shopyo_db) is True
194 assert part_expected_out in result.output
196 def test_clean_on_shopyo_db_file(self, tmpdir, flask_app):
197 """
198 run `shopyo clean2 -v` on the following test directory:
200 <some-unique-tmpdir>/
201 shopyo.db
202 """
203 shopyo_db = tmpdir.join("shopyo.db")
204 shopyo_db.write("content")
205 os.chdir(tmpdir)
206 runner = flask_app.test_cli_runner()
207 result = runner.invoke(cli, ["clean", "-v"])
208 expected_out1 = "[x] all tables dropped"
209 expected_out2 = "[ ] __pycache__ doesn't exist"
210 expected_out3 = (
211 f"[x] file '{os.path.join(tmpdir, 'shopyo.db')}' successfully deleted"
212 )
213 expected_out4 = f"[ ] unable to delete {os.path.join(tmpdir, 'migrations')}"
215 assert result.exit_code == 0
216 assert os.path.exists(shopyo_db) is False
217 assert expected_out1 in result.output
218 assert expected_out2 in result.output
219 assert expected_out3 in result.output
220 assert expected_out4 in result.output
222 def test_clean_on_skip_migration_folder(self, tmpdir, flask_app):
223 """
224 run `shopyo clean2 -v` on the following test directory:
226 <some-unique-tmpdir>/
227 migrations/
228 env.py
229 alembic.ini
230 """
231 migrations_path = tmpdir.mkdir("migrations")
232 env = migrations_path.join("env.py")
233 alembic = migrations_path.join("alembic.ini")
234 env.write("content-env")
235 alembic.write("content-alembic")
236 os.chdir(tmpdir)
237 runner = flask_app.test_cli_runner(mix_stderr=False)
238 result = runner.invoke(cli, ["clean", "--no-clear-migration", "-v"])
239 part_expected_out = "[ ] migration folder delete skipped"
241 assert result.exit_code == 0
242 assert os.path.exists(migrations_path) is True
243 assert part_expected_out in result.stdout
245 def test_clean_on_migration_folder(self, tmpdir, flask_app):
246 """
247 run `shopyo clean2 -v` on the following test directory:
249 <some-unique-tmpdir>/
250 migrations/
251 env.py
252 alembic.ini
253 """
254 migrations_path = tmpdir.mkdir("migrations")
255 env = migrations_path.join("env.py")
256 alembic = migrations_path.join("alembic.ini")
257 env.write("content-env")
258 alembic.write("content-alembic")
259 os.chdir(tmpdir)
260 runner = flask_app.test_cli_runner(mix_stderr=False)
261 result = runner.invoke(cli, ["clean", "-v"])
262 expected_out = (
263 "[x] all tables dropped\n"
264 f"[x] folder '{os.path.join(tmpdir, 'migrations')}' "
265 "successfully deleted\n"
266 )
267 expected_err_pycache = "[ ] __pycache__ doesn't exist\n"
268 expected_err_shopyo_db = (
269 f"[ ] unable to delete {os.path.join(tmpdir, 'shopyo.db')}"
270 )
272 assert result.exit_code == 0
273 assert os.path.exists(migrations_path) is False
274 assert expected_out in result.stdout
275 assert expected_err_pycache in result.stderr
276 assert expected_err_shopyo_db in result.stderr
278 @pytest.mark.parametrize("option", ["-v", "--verbose"])
279 def test_clean_pycache_shopyo_migration(self, tmpdir, flask_app, option):
280 """
281 run `shopyo clean2 -v` on the following test directory
283 shopyo/
284 shopyo/
285 migrations/
286 alembic.ini
287 env.py
288 module1/
289 __pycache__/
290 file.pyc
291 module2/
292 __pycache__/
293 file.pyc
294 shopyo.db
295 """
296 shopyo_path = tmpdir.mkdir("shopyo").mkdir("shopyo")
297 migrations_path = shopyo_path.mkdir("migrations")
298 env = migrations_path.join("env.py")
299 env.write("content-env")
300 alembic = migrations_path.join("alembic.ini")
301 alembic.write("content-alembic")
302 pycache_path1 = shopyo_path.mkdir("module1").mkdir("__pycache__")
303 pycache_path2 = shopyo_path.mkdir("module2").mkdir("__pycache__")
304 pyc1 = pycache_path1.join("file.pyc")
305 pyc1.write("content")
306 pyc2 = pycache_path2.join("file.pyc")
307 pyc2.write("content")
308 shopyo_db = shopyo_path.join("shopyo.db")
309 shopyo_db.write("content")
310 os.chdir(shopyo_path)
311 runner = flask_app.test_cli_runner()
312 result = runner.invoke(cli, ["clean", option])
313 expected_out1 = "[x] all tables dropped"
314 expected_out2 = "[x] __pycache__ successfully deleted"
315 expected_out3 = (
316 f"[x] file '{os.path.join(shopyo_path, 'shopyo.db')}' successfully deleted"
317 )
318 expected_out4 = (
319 f"[x] folder '{os.path.join(shopyo_path, 'migrations')}' successfully"
320 " deleted\n"
321 )
323 assert result.exit_code == 0
324 assert expected_out1 in result.output
325 assert expected_out2 in result.output
326 assert expected_out3 in result.output
327 assert expected_out4 in result.output
328 assert os.path.exists(migrations_path) is False
329 assert os.path.exists(pycache_path1) is False
330 assert os.path.exists(pycache_path2) is False
331 assert os.path.exists(shopyo_db) is False
333 def test_no_clean_on_shopyo_and_migrations(self, tmpdir):
334 """
335 run test on the following test directory:
337 <some-unique-tmpdir>/
338 migrations/
339 shopyo.db
340 """
341 migrations_path = tmpdir.mkdir("migrations")
342 shopyo_db = tmpdir.join("shopyo.db")
343 shopyo_db.write("content")
345 assert os.path.exists(migrations_path)
346 assert os.path.exists(shopyo_db)
348 @pytest.mark.parametrize("option", ["-v", "--verbose"])
349 def test_clean_on_no_files_to_clean(self, tmpdir, flask_app, option):
350 os.chdir(tmpdir)
351 runner = flask_app.test_cli_runner(mix_stderr=False)
352 result = runner.invoke(cli, ["clean", option])
353 expected_out = "[x] all tables dropped\n"
354 expected_err_pycache = "[ ] __pycache__ doesn't exist\n"
355 expected_err_shopyo_db = (
356 f"[ ] unable to delete {os.path.join(tmpdir, 'shopyo.db')}"
357 )
358 expected_err_migrations = (
359 f"[ ] unable to delete {os.path.join(tmpdir, 'migrations')}"
360 )
362 assert result.exit_code == 0
363 assert expected_out in result.output
364 assert expected_err_pycache in result.stderr
365 assert expected_err_shopyo_db in result.stderr
366 assert expected_err_migrations in result.stderr
368 def test_clean_with_no_verbose_on_empty_dir(self, tmpdir, flask_app):
369 """
370 run `shopyo clean2` on empty directory
371 """
372 os.chdir(tmpdir)
373 runner = flask_app.test_cli_runner(mix_stderr=False)
374 result = runner.invoke(cli, ["clean"])
375 expect_out = "Cleaning...\n" + SEP_CHAR * SEP_NUM + "\n"
377 assert result.exit_code == 0
378 assert expect_out in result.output
380 def test_clean_with_no_verbose_on_all_files(self, tmpdir, flask_app):
381 """
382 run `shopyo clean2` in directory with all files(shopyo.db,
383 migrations/, __pycahce__/)
384 """
385 pycache_path = tmpdir.mkdir("__pycache__")
386 shopyo_path = tmpdir.join("shopyo.db")
387 shopyo_path.write("content")
388 migrations_path = tmpdir.mkdir("migrations")
389 os.chdir(tmpdir)
390 runner = flask_app.test_cli_runner(mix_stderr=False)
391 result = runner.invoke(cli, ["clean"])
392 expect_out1 = "Cleaning...\n" + SEP_CHAR * SEP_NUM + "\n"
393 expect_out2 = "[x] __pycache__ successfully deleted\n"
394 expect_out3 = "[ ] unable to delete"
396 assert result.exit_code == 0
397 assert expect_out1 in result.output
398 assert expect_out2 not in result.output
399 assert expect_out3 not in result.output
400 assert os.path.exists(pycache_path) is False
401 assert os.path.exists(shopyo_path) is False
402 assert os.path.exists(migrations_path) is False
404 # TODO: add test_clean for MySQL to see if tables dropped @rehmanis
407@pytest.mark.usefixtures("restore_cwd")
408class TestCliNew:
409 @pytest.mark.parametrize("proj,parent", [("", "foo"), ("bar", "")])
410 def test_new_projname_already_exists(self, cli_runner, proj, parent, tmp_path):
411 name = proj or parent
412 parent_path = tmp_path / parent
413 proj_path = parent_path / name
414 proj_path.mkdir(parents=True)
415 os.chdir(parent_path)
416 result = cli_runner("new", proj)
417 expected_out = (
418 f"[ ] Error: Unable to create new project. Path {proj_path} exits"
419 )
421 assert result.exit_code == 1
422 assert expected_out in result.output
424 def test_new_project_invvalid_projname(self, cli_runner):
425 result = cli_runner("new", ")foo?")
426 expected_out = (
427 "[ ] Error: PROJNAME is not valid, please use alphanumeric "
428 "and underscore only"
429 )
431 assert result.exit_code == 1
432 assert expected_out in result.output
434 @pytest.mark.parametrize("proj,parent", [("", "foo"), ("bar", "")])
435 def test_new_project_valid_name(self, cli_runner, tmp_path, proj, parent):
437 # create the parent folder for foo and none for bar proj
438 temp_proj = tmp_path / parent
439 # print(temp_proj)
440 temp_proj.mkdir(exist_ok=True)
441 # change to the parent folder (in case of bar it tmp_path while for foo
442 # it is tmp_path/foo) and run the new command. For foo, there is no
443 # argument for proj provided so it will create a foo/ project inside
444 # tmp_path/foo while for bar it will create bar/bar/ inside tmp_path
445 os.chdir(temp_proj)
446 result = cli_runner("new", proj)
447 # change back to tmp_path so that for easier comparision
448 os.chdir(tmp_path)
449 # use this for the name of the project that was created in tmp_path
450 name = parent or proj
452 assert result.exit_code == 0
453 assert os.path.exists(os.path.join(name, name))
454 assert os.path.exists(os.path.join(name, "requirements.txt"))
455 assert os.path.exists(os.path.join(name, "dev_requirements.txt"))
456 assert os.path.exists(os.path.join(name, "tox.ini"))
457 assert os.path.exists(os.path.join(name, "MANIFEST.in"))
458 assert os.path.exists(os.path.join(name, "README.md"))
459 assert os.path.exists(os.path.join(name, ".gitignore"))
460 assert os.path.exists(os.path.join(name, "pytest.ini"))
461 assert os.path.exists(os.path.join(name, "setup.py"))
462 assert os.path.exists(os.path.join(name, name, "__init__.py"))
463 assert os.path.exists(os.path.join(name, name, "cli.py"))
464 assert os.path.exists(os.path.join(name, "docs"))
465 assert os.path.exists(os.path.join(name, "docs", "conf.py"))
466 assert os.path.exists(os.path.join(name, "docs", "_static"))
467 assert os.path.exists(os.path.join(name, "docs", "_static", "custom.css"))
468 assert os.path.exists(os.path.join(name, "docs", "Makefile"))
469 assert os.path.exists(os.path.join(name, "docs", "index.rst"))
470 assert os.path.exists(os.path.join(name, "docs", "docs.rst"))
471 assert not os.path.exists(os.path.join(name, name, "__main__.py"))
472 assert not os.path.exists(os.path.join(name, name, "api"))
473 assert not os.path.exists(os.path.join(name, name, ".tox"))
474 assert not os.path.exists(os.path.join(name, name, ".coverage"))
475 assert not os.path.exists(os.path.join(name, name, "shopyo.db"))
476 assert not os.path.exists(os.path.join(name, name, "testing.db"))
477 assert not os.path.exists(os.path.join(name, name, "coverage.xml"))
478 assert not os.path.exists(os.path.join(name, name, "setup.cfg"))
479 assert not os.path.exists(os.path.join(name, name, "instance"))
480 assert not os.path.exists(os.path.join(name, name, "migrations"))
481 assert not os.path.exists(os.path.join(name, name, "__pycache__"))
482 assert not os.path.exists(os.path.join(name, name, "config.json"))
485class TestCliInitialise:
486 pass
489@pytest.mark.usefixtures("fake_foo_proj")
490class TestCliStartapp:
491 @pytest.mark.parametrize("mod", ["box_bar", "box__foo"])
492 def test_create_invalid_modulename_with_box_prefix(self, cli_runner, mod):
493 result = cli_runner("startapp", mod)
494 expected_out = (
495 f"[ ] Invalid MODULENAME '{mod}'. MODULENAME cannot start"
496 " with box_ prefix\n"
497 )
499 assert result.exit_code != 0
500 assert expected_out in result.output
502 @pytest.mark.parametrize("box", ["box_bar", "boxfoo", "foo"])
503 def test_create_module_with_invalid_box_name(self, cli_runner, box):
504 result = cli_runner("startapp", "demo", box)
505 expected_out = (
506 f"[ ] Invalid BOXNAME '{box}'. BOXNAME should start with 'box__' prefix\n"
507 )
509 assert result.exit_code != 0
510 assert expected_out in result.output
512 @pytest.mark.parametrize(
513 "mod,box",
514 [
515 ("bar", ""),
516 ("foo", "box__default"),
517 ("foo", ""),
518 ("baz", "box__default"),
519 ("demo", "box__default"),
520 ],
521 )
522 def test_create_existing_module(self, cli_runner, mod, box, tmpdir):
523 result = cli_runner("startapp", mod, box)
524 expected_out = (
525 f"[ ] Unable to create module '{mod}'. "
526 "MODULENAME already exists inside modules/ at"
527 )
529 assert result.exit_code != 0
530 assert expected_out in result.output
532 def test_create_modulename_not_alphanumeric(self, cli_runner):
533 result = cli_runner("startapp", "my(demo)mod")
534 expected_out = (
535 "[ ] Error: MODULENAME is not valid, please use alphanumeric "
536 "and underscore only\n"
537 )
539 assert result.exit_code != 0
540 assert expected_out in result.output
542 def test_create_boxname_not_alphanumeric(self, cli_runner):
543 result = cli_runner("startapp", "mod", "box__?.game")
544 expected_out = (
545 "[ ] Error: BOXNAME is not valid, please use alphanumeric "
546 "and underscore only\n"
547 )
549 assert result.exit_code != 0
550 assert expected_out in result.output
552 @pytest.mark.parametrize(
553 "mod,box",
554 [
555 ("store", ""), # create module
556 ("store", "box__ecommerce"), # create submodule and also box
557 ("marketplace", "box__default"), # create submodule but not box
558 ],
559 )
560 def test_create_valid_modules(self, cli_runner, fake_foo_proj, mod, box):
561 result = cli_runner("startapp", mod, box)
562 module_path = os.path.join(fake_foo_proj, "modules", box, mod)
564 assert result.exit_code == 0
565 assert os.path.exists(module_path)
566 assert os.path.exists(os.path.join(module_path, "templates"))
567 assert os.path.exists(os.path.join(module_path, "templates", mod))
568 assert os.path.exists(
569 os.path.join(module_path, "templates", mod, "blocks", "sidebar.html")
570 )
571 assert os.path.exists(
572 os.path.join(module_path, "templates", mod, "dashboard.html")
573 )
574 assert os.path.exists(os.path.join(module_path, "tests"))
575 assert os.path.exists(os.path.join(module_path, "static"))
576 assert os.path.exists(
577 os.path.join(module_path, "tests", f"test_{mod}_functional.py")
578 )
579 assert os.path.exists(
580 os.path.join(module_path, "tests", f"test_{mod}_models.py")
581 )
582 assert os.path.exists(os.path.join(module_path, "view.py"))
583 assert os.path.exists(os.path.join(module_path, "forms.py"))
584 assert os.path.exists(os.path.join(module_path, "models.py"))
585 assert os.path.exists(os.path.join(module_path, "info.json"))
586 assert os.path.exists(os.path.join(module_path, "global.py"))
588 @pytest.mark.parametrize("opt", ["-v", "--verbose"])
589 def test_create_valid_module_with_verbose(self, cli_runner, fake_foo_proj, opt):
590 result = cli_runner("startapp", "store", opt)
591 module_path = os.path.join(fake_foo_proj, "modules", "store")
592 expected_out1 = "[x] Successfully created"
593 expected_out2 = "created with content"
595 assert result.exit_code == 0
596 assert os.path.exists(module_path)
597 assert expected_out1 in result.output
598 assert expected_out2 in result.output
601@pytest.mark.usefixtures("fake_foo_proj")
602class TestCliCollectstatic:
603 def test_collectstatic_with_default_src(self, cli_runner):
604 result = cli_runner("collectstatic")
605 expected_out1 = "Collecting static...\n" + SEP_CHAR * SEP_NUM + "\n\n"
606 expected_out2 = "[x] done copying"
608 assert result.exit_code == 0
609 assert expected_out1 in result.output
610 assert expected_out2 not in result.output
611 assert os.path.exists("static/modules/bar/bar.css")
612 assert os.path.exists("static/modules/box__default/foo/foo.css")
613 assert len(os.listdir("static/modules")) == 2
614 assert len(os.listdir("static/modules/box__default")) == 2
616 @pytest.mark.parametrize(
617 "src,expected",
618 [
619 ("box__default", "box__default/foo/foo.css"),
620 ("box__default", "box__default/zoo/zoo.css"),
621 ("box__default/foo", "box__default/foo/foo.css"),
622 ("bar", "bar/bar.css"),
623 ("box__default\\foo", "box__default/foo/foo.css"),
624 ("modules/bar", "bar/bar.css"),
625 ("modules\\box__default/foo", "box__default/foo/foo.css"),
626 ],
627 )
628 def test_collectstatic_with_valid_arg(self, src, expected, cli_runner):
629 result = cli_runner("collectstatic", src)
630 expected_out1 = "Collecting static...\n" + SEP_CHAR * SEP_NUM + "\n\n"
631 expected_out2 = "[x] done copying"
633 assert result.exit_code == 0
634 assert expected_out1 in result.output
635 assert expected_out2 not in result.output
636 assert os.path.exists(f"static/modules/{expected}")
637 assert len(os.listdir("static/modules")) == 1
639 def test_collectstatic_with_invalid_arg(self, cli_runner):
641 result = cli_runner("collectstatic", "foobar")
642 modules_path = os.path.join("modules", "foobar")
643 modules_path = os.path.join(os.getcwd(), modules_path)
644 expected_out = f"[ ] path: {modules_path} does not exist"
646 assert result.exit_code != 0
647 assert expected_out in result.output
648 assert not os.path.exists("static/modules")
650 @pytest.mark.parametrize("option", ["-v", "--verbose"])
651 def test_collectstatic_with_verbose(self, cli_runner, option):
653 result = cli_runner("collectstatic", option)
654 expected_out1 = "Collecting static...\n" + SEP_CHAR * SEP_NUM + "\n"
655 expected_out2 = "[x] done copying"
657 assert result.exit_code == 0
658 assert expected_out1 in result.output
659 assert expected_out2 in result.output